@pactor-app/runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,909 @@
+// src/context/adapters.ts
+function createDefaultPermissionAdapter() {
+  return { check: () => true };
+}
+function createDefaultRouterAdapter() {
+  return {
+    navigate(to) {
+      console.warn(
+        `[@pactor-app/runtime] RouterAdapter \u672A\u6CE8\u5165\uFF0Cnavigate("${to}") \u5DF2\u5FFD\u7565`
+      );
+    }
+  };
+}
+function createFetchHttpAdapter() {
+  return {
+    async request(config) {
+      const method = (config.method ?? "GET").toUpperCase();
+      let url = config.url;
+      if (config.params) {
+        const search = new URLSearchParams();
+        for (const [key, value] of Object.entries(config.params)) {
+          if (value !== void 0 && value !== null) {
+            search.set(key, String(value));
+          }
+        }
+        const query = search.toString();
+        if (query) {
+          url += (url.includes("?") ? "&" : "?") + query;
+        }
+      }
+      const headers = { ...config.headers };
+      let body;
+      if (config.body !== void 0) {
+        headers["content-type"] ?? (headers["content-type"] = "application/json");
+        body = JSON.stringify(config.body);
+      }
+      const response = await fetch(url, { method, headers, body });
+      if (!response.ok) {
+        throw new Error(
+          `[@pactor-app/runtime] http request failed: ${response.status} ${response.statusText} (${config.url})`
+        );
+      }
+      const text = await response.text();
+      if (!text) {
+        return void 0;
+      }
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    }
+  };
+}
+
+// src/context/context.ts
+import { Registry, createI18nContext } from "@pactor-app/core";
+
+// src/utils/resolve.ts
+import {
+  hasExpression,
+  resolveTemplate
+} from "@pactor-app/expression";
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveDeep(value, scope, options = {}) {
+  if (typeof value === "string") {
+    return hasExpression(value) ? resolveTemplate(value, scope) : value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveDeep(item, scope, options));
+  }
+  if (isPlainRecord(value)) {
+    if (options.isOpaque?.(value)) {
+      return value;
+    }
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      out[key] = resolveDeep(item, scope, options);
+    }
+    return out;
+  }
+  return value;
+}
+function toError(cause) {
+  return cause instanceof Error ? cause : new Error(String(cause));
+}
+
+// src/datasource/data-store.ts
+var DataStore = class {
+  constructor(deps) {
+    this.statuses = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.version = 0;
+    this.configs = deps.dataSources;
+    this.services = deps.services;
+    this.http = deps.http;
+    this.getScope = deps.getScope;
+    for (const name of Object.keys(deps.dataSources)) {
+      this.statuses.set(name, { loading: false });
+    }
+  }
+  /** 状态快照（未知名返回空状态，不抛错） */
+  get(name) {
+    return this.statuses.get(name) ?? { loading: false };
+  }
+  /** 同 `get(name)`，语义化别名 */
+  getStatus(name) {
+    return this.get(name);
+  }
+  getData(name) {
+    return this.get(name).data;
+  }
+  /** 各数据源当前数据，供表达式作用域的 `data` 键使用 */
+  getAllData() {
+    const out = {};
+    for (const [name, status] of this.statuses) {
+      out[name] = status.data;
+    }
+    return out;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** 版本号，供 `useSyncExternalStore` 的 getSnapshot 使用 */
+  getVersion() {
+    return this.version;
+  }
+  /** 触发所有 `autoLoad: true` 的数据源（PageRuntime 初始化阶段调用） */
+  init() {
+    return Promise.all(this.autoLoadNames().map((name) => this.load(name)));
+  }
+  /**
+   * 加载指定数据源。状态流转：开始置 loading 并清空 error；
+   * 成功写入 data；失败写入 error（保留旧 data）。MUST NOT 抛出。
+   */
+  async load(name) {
+    const config = this.configs[name];
+    if (!config) {
+      throw new Error(`[@pactor-app/runtime] unknown dataSource: "${name}"`);
+    }
+    const previous = this.get(name);
+    this.update(name, { loading: true, error: void 0, data: previous.data });
+    try {
+      const data = await this.loadByType(config);
+      this.update(name, { loading: false, data, error: void 0 });
+    } catch (cause) {
+      this.update(name, {
+        loading: false,
+        error: toError(cause),
+        data: previous.data
+      });
+    }
+  }
+  /** 重新加载指定数据源（语义同 `load`，供模板与 Action 调用） */
+  refresh(name) {
+    return this.load(name);
+  }
+  /**
+   * reload 语义：指定名称时刷新该数据源；
+   * 缺省时刷新全部 autoLoad 数据源（供 Action 引擎 `reload` 动作调用）。
+   */
+  reload(name) {
+    if (name !== void 0) {
+      return this.load(name);
+    }
+    return Promise.all(this.autoLoadNames().map((n) => this.load(n)));
+  }
+  autoLoadNames() {
+    return Object.entries(this.configs).filter(([, config]) => config.autoLoad === true).map(([name]) => name);
+  }
+  async loadByType(config) {
+    switch (config.type) {
+      case "static":
+        return config.value;
+      case "service": {
+        const serviceName = config.service ?? "";
+        const handler = this.services.get(serviceName);
+        if (!handler) {
+          throw new Error(
+            `[@pactor-app/runtime] service not registered: "${serviceName}"`
+          );
+        }
+        const params = resolveDeep(config.params ?? {}, this.getScope());
+        return handler(params);
+      }
+      case "http": {
+        if (!config.request) {
+          throw new Error("[@pactor-app/runtime] http dataSource \u7F3A\u5C11 request \u914D\u7F6E");
+        }
+        const request = resolveDeep(
+          config.request,
+          this.getScope()
+        );
+        return this.http.request(request);
+      }
+      default:
+        throw new Error(
+          `[@pactor-app/runtime] unsupported dataSource type: "${config.type}"`
+        );
+    }
+  }
+  update(name, status) {
+    this.statuses.set(name, status);
+    this.version += 1;
+    for (const listener of [...this.listeners]) {
+      listener();
+    }
+  }
+};
+
+// src/context/scope.ts
+function buildScope(context, local) {
+  return {
+    app: context.app,
+    page: context.page,
+    state: context.state.getState(),
+    form: context.state.get("form"),
+    data: context.data.getAllData(),
+    route: context.route,
+    user: context.user,
+    params: context.route.params,
+    actions: context.actionResults,
+    locale: context.locale,
+    t: context.i18n.t,
+    ...local
+  };
+}
+
+// src/context/state-store.ts
+var StateStore = class {
+  constructor(initialState = {}) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.version = 0;
+    this.initialState = initialState;
+    this.state = initialState;
+  }
+  /** 当前完整 state 对象 */
+  getState() {
+    return this.state;
+  }
+  /** 按点路径读取，如 `get('user.name')`；路径不存在时返回 undefined */
+  get(path) {
+    let current = this.state;
+    for (const key of path.split(".")) {
+      if (typeof current !== "object" || current === null) {
+        return void 0;
+      }
+      current = current[key];
+    }
+    return current;
+  }
+  set(patchOrPath, value) {
+    if (typeof patchOrPath === "string") {
+      this.state = setPath(this.state, patchOrPath.split("."), value);
+    } else {
+      this.state = { ...this.state, ...patchOrPath };
+    }
+    this.notify();
+  }
+  /** 恢复为创建时的初始值 */
+  reset() {
+    this.state = this.initialState;
+    this.notify();
+  }
+  /** 订阅变化，返回退订函数 */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * 单调递增的版本号，供 `useSyncExternalStore` 的 getSnapshot 使用
+   * （V1 简化策略：任一变化重渲染整棵 DSL 树）。
+   */
+  getVersion() {
+    return this.version;
+  }
+  notify() {
+    this.version += 1;
+    for (const listener of [...this.listeners]) {
+      listener();
+    }
+  }
+};
+function setPath(source, path, value) {
+  const [key, ...rest] = path;
+  if (key === void 0) {
+    return source;
+  }
+  const clone = { ...source };
+  if (rest.length === 0) {
+    clone[key] = value;
+    return clone;
+  }
+  const child = clone[key];
+  clone[key] = setPath(
+    typeof child === "object" && child !== null && !Array.isArray(child) ? child : {},
+    rest,
+    value
+  );
+  return clone;
+}
+
+// src/context/context.ts
+function createRuntimeContext(options = {}) {
+  const state = new StateStore(options.state);
+  const services = options.services ?? new Registry("ServiceRegistry");
+  const components = options.components ?? new Registry("ComponentRegistry");
+  const actions = options.actions ?? new Registry("ActionRegistry");
+  const forms = options.forms ?? new Registry("FormRegistry");
+  const capabilities = options.capabilities ?? new Registry("CapabilityRegistry");
+  const permission = options.permission ?? createDefaultPermissionAdapter();
+  const router = options.router ?? createDefaultRouterAdapter();
+  const http = options.http ?? createFetchHttpAdapter();
+  const route = {
+    params: options.route?.params ?? {},
+    query: options.route?.query ?? {},
+    navigate: (to) => router.navigate(to)
+  };
+  let context;
+  const data = new DataStore({
+    dataSources: options.dataSources ?? {},
+    services,
+    http,
+    getScope: () => buildScope(context)
+  });
+  context = {
+    app: options.app ?? {},
+    page: options.page ?? {},
+    state,
+    data,
+    route,
+    user: options.user ?? {},
+    services,
+    components,
+    actions,
+    forms,
+    actionResults: {},
+    permission,
+    capabilities,
+    http,
+    locale: options.locale ?? "zh-CN",
+    i18n: createI18nContext({
+      locale: options.locale,
+      defaultLocale: options.defaultLocale,
+      messages: options.messages
+    })
+  };
+  return context;
+}
+
+// src/context/i18n-context.ts
+import { createI18nContext as createI18nContext2 } from "@pactor-app/core";
+import { createContext, useContext } from "react";
+var I18nReactContext = createContext(null);
+var I18nContextProvider = I18nReactContext.Provider;
+var defaultI18n = createI18nContext2({
+  messages: {
+    "pactor.layout.expandSidebar": "\u5C55\u5F00\u4FA7\u8FB9\u680F",
+    "pactor.layout.collapseSidebar": "\u6536\u8D77\u4FA7\u8FB9\u680F",
+    "pactor.layout.closeTab": "\u5173\u95ED {{title}}",
+    "pactor.layout.breadcrumb": "\u9762\u5305\u5C51",
+    "pactor.table.loading": "\u52A0\u8F7D\u4E2D\u2026",
+    "pactor.table.empty": "\u6682\u65E0\u6570\u636E",
+    "pactor.form.required": "\u5FC5\u586B",
+    "pactor.select.clear": "\u6E05\u9664"
+  }
+});
+function useI18n() {
+  const value = useContext(I18nReactContext);
+  if (value === null) {
+    return defaultI18n;
+  }
+  return {
+    ...value,
+    t: (key, params) => {
+      const translated = value.t(key, params);
+      return translated === key ? defaultI18n.t(key, params) : translated;
+    }
+  };
+}
+
+// src/action/builtins.ts
+function registerBuiltinActions(registry) {
+  const register = (name, handler) => {
+    if (!registry.has(name)) {
+      registry.register(name, handler);
+    }
+  };
+  register("setState", (action, ctx) => {
+    ctx.context.state.set(action.params ?? {});
+    return { ok: true };
+  });
+  register("resetState", (_action, ctx) => {
+    ctx.context.state.reset();
+    return { ok: true };
+  });
+  register("reload", async (action, ctx) => {
+    const target = action.params?.["dataSource"];
+    await ctx.context.data.reload(
+      typeof target === "string" ? target : void 0
+    );
+    return { ok: true };
+  });
+  register("request", async (action, ctx) => {
+    const params = action.params ?? {};
+    const { target, method, url, headers, body } = params;
+    if (typeof url !== "string" || !url) {
+      return {
+        ok: false,
+        error: new Error("[@pactor-app/runtime] request \u52A8\u4F5C\u7F3A\u5C11 url \u53C2\u6570")
+      };
+    }
+    try {
+      const data = await ctx.context.http.request({
+        method: typeof method === "string" ? method : void 0,
+        url,
+        params: isRecord(params["params"]) ? params["params"] : void 0,
+        headers: isStringRecord(headers) ? headers : void 0,
+        body
+      });
+      if (typeof target === "string" && target) {
+        const path = target.startsWith("state.") ? target.slice(6) : target;
+        ctx.context.state.set(path, data);
+      }
+      return { ok: true, data };
+    } catch (cause) {
+      return {
+        ok: false,
+        error: cause instanceof Error ? cause : new Error(String(cause))
+      };
+    }
+  });
+  register("sequence", async (action, ctx) => {
+    for (const child of asActions(action.params?.["actions"])) {
+      const result = await ctx.execute(child);
+      if (!result.ok) {
+        return result;
+      }
+    }
+    return { ok: true };
+  });
+  register("parallel", async (action, ctx) => {
+    const results = await Promise.all(
+      asActions(action.params?.["actions"]).map((child) => ctx.execute(child))
+    );
+    const failed = results.find((result) => !result.ok);
+    return failed ?? { ok: true, data: results };
+  });
+  register("if", async (action, ctx) => {
+    const branch = action.params?.["condition"] ? action.params?.["then"] : action.params?.["else"];
+    for (const child of asActions(branch)) {
+      const result = await ctx.execute(child);
+      if (!result.ok) {
+        return result;
+      }
+    }
+    return { ok: true };
+  });
+  register(
+    "delay",
+    (action) => new Promise((resolve) => {
+      const ms = Number(action.params?.["ms"] ?? 0);
+      setTimeout(() => resolve({ ok: true }), Number.isFinite(ms) ? ms : 0);
+    })
+  );
+  register("form.setValues", (action, ctx) => {
+    const formName = action.params?.["form"];
+    const name = typeof formName === "string" && formName !== "" ? formName : "default";
+    const handle = ctx.context.forms.get(name);
+    if (!handle) {
+      return {
+        ok: false,
+        error: new Error(
+          `[@pactor-app/runtime] form.setValues \u76EE\u6807\u8868\u5355\u672A\u6CE8\u518C: "${name}"`
+        )
+      };
+    }
+    const values = action.params?.["values"];
+    if (!isRecord(values)) {
+      return {
+        ok: false,
+        error: new Error("[@pactor-app/runtime] form.setValues \u7F3A\u5C11 params.values\uFF08object\uFF09")
+      };
+    }
+    handle.setValues(values);
+    return { ok: true };
+  });
+}
+function asActions(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (isRecord(value) && typeof value["action"] === "string") {
+    return [value];
+  }
+  return [];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((v) => typeof v === "string");
+}
+
+// src/action/engine.ts
+import {
+  resolveTemplate as resolveTemplate2
+} from "@pactor-app/expression";
+var ActionEngine = class {
+  constructor(context) {
+    this.context = context;
+  }
+  async execute(action, localScope) {
+    const scope = buildScope(this.context, localScope);
+    let result;
+    try {
+      if (action.condition !== void 0) {
+        const expression = typeof action.condition === "string" ? action.condition : action.condition.expression;
+        if (!resolveTemplate2(expression, scope)) {
+          result = { ok: true, skipped: true };
+          this.recordNamedResult(action, result);
+          return result;
+        }
+      }
+      if (action.permission !== void 0 && !this.context.permission.check(action.permission)) {
+        result = {
+          ok: false,
+          error: new Error(
+            `[@pactor-app/runtime] permission denied for action "${action.action}"`
+          )
+        };
+        this.recordNamedResult(action, result);
+        return result;
+      }
+      const handler = this.context.actions.get(action.action);
+      if (!handler) {
+        result = {
+          ok: false,
+          error: new Error(
+            `[@pactor-app/runtime] action not registered: "${action.action}"`
+          )
+        };
+        this.recordNamedResult(action, result);
+        return result;
+      }
+      const resolvedAction = {
+        ...action,
+        // 内嵌的子动作配置（sequence/parallel/if 的 actions/then/else）
+        // 与内嵌的 DslNode 子树（overlay.open 的 content 等，约定同
+        // Renderer 的 resolveProps）保持原样，由各自执行/渲染时
+        // 按当时的 state 与作用域求值
+        params: resolveDeep(action.params ?? {}, scope, {
+          isOpaque: (value) => typeof value["action"] === "string" || typeof value["type"] === "string"
+        })
+      };
+      const ctx = {
+        context: this.context,
+        scope,
+        // 子动作继承局部作用域（而非作用域快照），保证 state 始终取当前值
+        execute: (child) => this.execute(child, localScope)
+      };
+      result = await handler(resolvedAction, ctx);
+    } catch (cause) {
+      result = { ok: false, error: toError(cause) };
+    }
+    this.recordNamedResult(action, result);
+    return result;
+  }
+  /** 命名动作结果落盘：成功 → data；失败 → `{ ok: false, error }` */
+  recordNamedResult(action, result) {
+    if (action.id === void 0) {
+      return;
+    }
+    this.context.actionResults[action.id] = result.ok ? result.data : { ok: false, error: result.error };
+  }
+  /** 事件动作数组按声明顺序串行执行 */
+  async executeAll(actions, localScope) {
+    const list = Array.isArray(actions) ? actions : [actions];
+    const results = [];
+    for (const action of list) {
+      results.push(await this.execute(action, localScope));
+    }
+    return results;
+  }
+};
+
+// src/renderer/renderer.tsx
+import {
+  resolveTemplate as resolveTemplate3
+} from "@pactor-app/expression";
+import {
+  createElement,
+  useMemo,
+  useSyncExternalStore as useSyncExternalStore2
+} from "react";
+
+// src/renderer/renderer-context.ts
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useSyncExternalStore
+} from "react";
+var RendererReactContext = createContext2(null);
+var RendererContextProvider = RendererReactContext.Provider;
+function useRenderer() {
+  const value = useContext2(RendererReactContext);
+  if (!value) {
+    throw new Error("[@pactor-app/runtime] useRenderer \u5FC5\u987B\u5728 <DslRenderer> \u5185\u4F7F\u7528");
+  }
+  return value;
+}
+function useRuntimeState(path) {
+  const { context } = useRenderer();
+  return useSyncExternalStore(
+    (onChange) => context.state.subscribe(onChange),
+    () => path === void 0 ? context.state.getState() : context.state.get(path)
+  );
+}
+function useDataSource(name) {
+  const { context } = useRenderer();
+  return useSyncExternalStore(
+    (onChange) => context.data.subscribe(onChange),
+    () => context.data.get(name)
+  );
+}
+
+// src/renderer/unsupported.tsx
+import { jsxs } from "react/jsx-runtime";
+function UnsupportedComponent({ type }) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-pactor-unsupported": type,
+      style: {
+        border: "1px dashed #d97706",
+        borderRadius: 4,
+        padding: 8,
+        color: "#b45309",
+        fontSize: 12
+      },
+      children: [
+        "Unsupported component: ",
+        type
+      ]
+    }
+  );
+}
+
+// src/renderer/renderer.tsx
+import { jsx, jsxs as jsxs2 } from "react/jsx-runtime";
+function DslRenderer({ context, node, engine, children }) {
+  useSyncExternalStore2(
+    (onChange) => {
+      const offState = context.state.subscribe(onChange);
+      const offData = context.data.subscribe(onChange);
+      return () => {
+        offState();
+        offData();
+      };
+    },
+    () => `${context.state.getVersion()}:${context.data.getVersion()}`
+  );
+  const resolvedEngine = useMemo(
+    () => engine ?? new ActionEngine(context),
+    [engine, context]
+  );
+  const value = useMemo(() => {
+    const root = {
+      context,
+      engine: resolvedEngine,
+      scope: {},
+      renderChildren: (children2, extraScope) => renderChildrenOf(root, children2, extraScope)
+    };
+    return root;
+  }, [context, resolvedEngine]);
+  return /* @__PURE__ */ jsxs2(RendererContextProvider, { value, children: [
+    node ? renderNode(node, value, node.id ?? "root") : null,
+    children
+  ] });
+}
+function renderNode(node, value, key) {
+  const scope = buildScope(value.context, value.scope);
+  if (node.when !== void 0) {
+    const expression = typeof node.when === "string" ? node.when : node.when.expression;
+    let visible;
+    try {
+      visible = resolveTemplate3(expression, scope);
+    } catch (cause) {
+      console.warn(
+        `[@pactor-app/runtime] when \u8868\u8FBE\u5F0F\u6C42\u503C\u5931\u8D25\uFF08\u8282\u70B9 "${node.type}"\uFF09`,
+        cause
+      );
+      visible = false;
+    }
+    if (!visible) {
+      return null;
+    }
+  }
+  let deniedStrategy;
+  if (node.permission !== void 0 && !value.context.permission.check(node.permission)) {
+    deniedStrategy = resolveDeniedStrategy(node.permission);
+    if (deniedStrategy === "hidden") {
+      return null;
+    }
+  }
+  const entry = value.context.components.get(node.type);
+  const normalized = normalizeEntry(entry);
+  if (!normalized) {
+    return /* @__PURE__ */ jsx(UnsupportedComponent, { type: node.type }, key);
+  }
+  const props = resolveProps(node.props, scope);
+  if (node.events) {
+    for (const [name, actions] of Object.entries(node.events)) {
+      props[name] = (event) => {
+        void value.engine.executeAll(actions, { ...value.scope, event });
+      };
+    }
+  }
+  if (deniedStrategy === "disabled") {
+    props["disabled"] = true;
+  } else if (deniedStrategy === "readonly") {
+    props["readOnly"] = true;
+  }
+  if (normalized.withScope) {
+    return createElement(normalized.component, {
+      key,
+      ...props,
+      dslChildren: node.children
+    });
+  }
+  return createElement(
+    normalized.component,
+    { key, ...props },
+    renderChildrenOf(value, node.children)
+  );
+}
+function resolveDeniedStrategy(permission) {
+  if (typeof permission === "object" && !Array.isArray(permission)) {
+    return permission.denied ?? "hidden";
+  }
+  return "hidden";
+}
+function renderChildrenOf(value, children, extraScope) {
+  if (!children || children.length === 0) {
+    return null;
+  }
+  if (!extraScope) {
+    return children.map(
+      (child, index) => renderNode(child, value, child.id ?? index)
+    );
+  }
+  const scoped = {
+    context: value.context,
+    engine: value.engine,
+    scope: { ...value.scope, ...extraScope },
+    renderChildren: (nested, nestedScope) => renderChildrenOf(scoped, nested, nestedScope)
+  };
+  return /* @__PURE__ */ jsx(RendererContextProvider, { value: scoped, children: children.map(
+    (child, index) => renderNode(child, scoped, child.id ?? index)
+  ) });
+}
+function normalizeEntry(entry) {
+  if (!entry) {
+    return void 0;
+  }
+  if (typeof entry === "object" && "component" in entry) {
+    return entry;
+  }
+  return { component: entry };
+}
+function resolveProps(props, scope) {
+  if (!props) {
+    return {};
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(props)) {
+    out[key] = typeof value === "string" && key.startsWith("on") ? value : resolveDeep(value, scope, { isOpaque: isEmbeddedDslNode });
+  }
+  return out;
+}
+function isEmbeddedDslNode(value) {
+  return typeof value.type === "string";
+}
+
+// src/page/page-runtime.tsx
+import {
+  validatePageDsl
+} from "@pactor-app/schema";
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+var PageRuntimeError = class extends Error {
+  constructor(errors) {
+    super(
+      `Page DSL \u6821\u9A8C\u5931\u8D25\uFF08${errors.length} \u4E2A\u9519\u8BEF\uFF09\uFF1A${errors.map((error) => `${error.path}: ${error.message}`).join("\uFF1B")}`
+    );
+    this.name = "PageRuntimeError";
+    this.errors = errors;
+  }
+};
+function createPageRuntime(pageDsl, options = {}) {
+  const validation = validatePageDsl(pageDsl);
+  if (!validation.valid) {
+    throw new PageRuntimeError(validation.errors);
+  }
+  const context = createRuntimeContext({
+    ...options,
+    page: pageDsl.page,
+    state: pageDsl.state ?? options.state,
+    dataSources: pageDsl.dataSources ?? options.dataSources
+  });
+  registerBuiltinActions(context.actions);
+  const engine = new ActionEngine(context);
+  let destroyed = false;
+  const lifecycleListeners = /* @__PURE__ */ new Set();
+  const runLifecycle = async (name) => {
+    for (const listener of [...lifecycleListeners]) {
+      listener(name);
+    }
+    const actions = pageDsl.lifecycle?.[name];
+    if (actions) {
+      await engine.executeAll(actions);
+    }
+  };
+  const initialized = Promise.resolve().then(async () => {
+    const loading = context.data.init();
+    await runLifecycle("onInit");
+    await loading;
+    await runLifecycle("onLoad");
+  });
+  const triggerWhenAlive = async (name) => {
+    if (destroyed) {
+      return;
+    }
+    await runLifecycle(name);
+  };
+  return {
+    pageDsl,
+    context,
+    engine,
+    initialized,
+    get destroyed() {
+      return destroyed;
+    },
+    render() {
+      if (!pageDsl.body) {
+        return null;
+      }
+      return /* @__PURE__ */ jsx2(DslRenderer, { context, node: pageDsl.body, engine });
+    },
+    ready: () => triggerWhenAlive("onReady"),
+    show: () => triggerWhenAlive("onShow"),
+    hide: () => triggerWhenAlive("onHide"),
+    async destroy() {
+      if (destroyed) {
+        return;
+      }
+      destroyed = true;
+      await runLifecycle("onDestroy");
+      lifecycleListeners.clear();
+      for (const key of Object.keys(context.actionResults)) {
+        delete context.actionResults[key];
+      }
+    },
+    onLifecycle(listener) {
+      lifecycleListeners.add(listener);
+      return () => {
+        lifecycleListeners.delete(listener);
+      };
+    }
+  };
+}
+function PageRuntimeView({
+  runtime,
+  children
+}) {
+  const body = runtime.pageDsl.body;
+  if (!body) {
+    return /* @__PURE__ */ jsx2(Fragment, { children: children ?? null });
+  }
+  return /* @__PURE__ */ jsx2(DslRenderer, { context: runtime.context, node: body, engine: runtime.engine, children });
+}
+export {
+  ActionEngine,
+  DataStore,
+  DslRenderer,
+  I18nContextProvider,
+  PageRuntimeError,
+  PageRuntimeView,
+  StateStore,
+  UnsupportedComponent,
+  buildScope,
+  createDefaultPermissionAdapter,
+  createDefaultRouterAdapter,
+  createFetchHttpAdapter,
+  createPageRuntime,
+  createRuntimeContext,
+  registerBuiltinActions,
+  resolveDeep,
+  useDataSource,
+  useI18n,
+  useRenderer,
+  useRuntimeState
+};