@blocklet/pages-kit-inner-components 0.6.0 → 0.6.2

package/lib/es/chunks/site-state-Bh8guIeX.js

@@ -0,0 +1,2092 @@
+import { getComponentMountPoint as dt } from "@blocklet/pages-kit/builtin/utils";
+import { PreloadComponentScriptModule as Ie } from "@blocklet/pages-kit/types";
+import { componentUMDName as ft, RenderNestedComponent as ke, mergeComponent as mt, getComponentDependencies as ht } from "@blocklet/pages-kit/utils/property";
+import { memoize as gt, BuiltinModules as ge } from "@blocklet/quickjs";
+import { BuiltinModules as Ee } from "@blocklet/pages-kit/utils/builtin";
+import E from "@blocklet/sdk/lib/config";
+import { LRUCache as le } from "lru-cache";
+import yt, { Headers as St } from "node-fetch";
+import { joinURL as V, getQuery as wt, withQuery as It, parseURL as De, withHttps as Et } from "ufo";
+import Pe from "lodash/isEmpty";
+import { createHash as bt } from "crypto";
+import { promises as M, readFileSync as J, mkdtempSync as Pt, existsSync as L, lstatSync as G, rmSync as Je, renameSync as Re, mkdirSync as F, writeFileSync as oe, copyFileSync as At, readdirSync as Ct, createWriteStream as Ot } from "fs";
+import Ke, { join as P, dirname as j, basename as x } from "path";
+import vt from "lodash/isNil";
+import Tt from "@blocklet/logger";
+import { isRelativeModule as kt, createBuiltinModuleTransformer as Dt } from "@blocklet/pages-kit/utils/typescript/builtin-module-transformer";
+import { getResources as Rt, getComponentWebEndpoint as xt, call as jt } from "@blocklet/sdk/lib/component";
+import { getYjsValue as z, syncedStore as $t } from "@syncedstore/core";
+import * as _ from "yjs";
+import { setPageDataSource as Mt } from "@blocklet/pages-kit/utils/data-source";
+import { getRouteMetaDataByOptionIds as Lt, generateParamCombinations as Ae } from "@blocklet/pages-kit/utils/route";
+import { cloneDeep as Nt } from "lodash";
+import { nextId as xe } from "@blocklet/pages-kit/utils/common";
+import { unzipSection as _t } from "@blocklet/pages-kit/utils/page-model";
+import { reactive as Ut } from "@reactivedata/reactive";
+import { globSync as se } from "glob";
+import * as ye from "lib0/decoding";
+import * as D from "lib0/encoding";
+import Ft from "lodash/cloneDeep";
+import ze from "lodash/debounce";
+import Ce from "lodash/get";
+import je from "lodash/set";
+import Bt from "lodash/union";
+import Vt from "p-limit";
+import { DataTypes as k, Sequelize as Gt, Model as He, Op as We } from "sequelize";
+import { pipeline as Jt } from "stream/promises";
+import { x as Kt } from "tar";
+import zt from "wait-on";
+import { Awareness as Ht, encodeAwarenessUpdate as $e, removeAwarenessStates as Wt, applyAwarenessUpdate as Yt } from "y-protocols/awareness";
+import { writeUpdate as qt, writeSyncStep1 as Qt, readSyncMessage as Xt } from "y-protocols/sync";
+import * as K from "yaml";
+import "sqlite3";
+import "@blocklet/pages-kit/types/state";
+E.env.mode;
+E.env.OPENAI_API_KEY || process.env.OPENAI_API_KEY;
+E.env.OPENAI_BASE_URL || process.env.OPENAI_BASE_URL;
+E.env.TRANSLATE_ADDITIONAL_PROMPT || process.env.TRANSLATE_ADDITIONAL_PROMPT;
+E.env.PAGE_CONTENT_ADDITIONAL_PROMPT || process.env.PAGE_CONTENT_ADDITIONAL_PROMPT;
+const Zt = "image-bin";
+E.env.INIT_TEMPLATE_PATH;
+const Ye = process.env.DATABASE_URL || Ke.join(E.env.dataDir, "db/pages-kit.db"), Me = E, Ns = () => E.env.tenantMode === "multiple", _s = () => (vt(Me.env.preferences.multiTenantAllProjectAccessPassports) ? [] : Me.env.preferences.multiTenantAllProjectAccessPassports?.split(",")) || [], eo = Ke.join(E.env.dataDir, "fs-memoize-cache"), to = E.env.FS_MEMOIZE_CACHE_VERSION || "v1.0.0", f = Tt("pages-kit"), oo = k.sqlite.DATE.parse;
+k.sqlite.DATE.parse = (t, e) => typeof t == "number" ? new Date(t) : oo(t, e);
+const U = new Gt({
+  dialect: "sqlite",
+  storage: Ye,
+  benchmark: process.env.ENABLE_SEQUELIZE_BENCHMARK === "true",
+  retry: {
+    match: [/SQLITE_BUSY/],
+    name: "query",
+    max: 10
+  },
+  // eslint-disable-next-line no-console
+  logging: process.env.ENABLE_SEQUELIZE_LOGGING === "true" ? console.log : !1
+  // logQueryParameters: true,
+});
+U.query("pragma journal_mode = WAL;");
+U.query("pragma synchronous = normal;");
+U.query("pragma journal_size_limit = 33554432;");
+U.query("pragma cache_size = -2000;");
+U.query("pragma mmap_size = 33554432;");
+process.on("SIGINT", async () => {
+  await U.close(), process.exit(0);
+});
+process.on("SIGTERM", async () => {
+  await U.close(), process.exit(0);
+});
+async function so(t, e) {
+  try {
+    if (t.getDialect() !== "sqlite")
+      return;
+    const [o] = await t.query("SELECT 1");
+    if (!o || o.length === 0)
+      return;
+    await t.query("PRAGMA shrink_memory;");
+  } catch (o) {
+    if (o.name === "SequelizeConnectionError" || o?.message && /closed!/.test(o.message))
+      return;
+    console.error("Failed to cleanup SQLite memory", e, o);
+  }
+}
+setInterval(
+  async () => {
+    f.info("Start cleanupSqliteMemory"), await so(U, Ye), f.info("End cleanupSqliteMemory");
+  },
+  60 * 1e3 * 10
+  // 10 minutes
+);
+class Oe extends He {
+  // Foreign key to Component
+}
+Oe.init(
+  {
+    id: {
+      type: k.UUID,
+      allowNull: !1,
+      primaryKey: !0,
+      defaultValue: k.UUIDV4
+    },
+    projectId: {
+      type: k.UUID,
+      allowNull: !1
+    },
+    componentId: {
+      type: k.STRING,
+      allowNull: !1
+    }
+  },
+  { sequelize: U, tableName: "ProjectComponents", timestamps: !1 }
+);
+class N extends He {
+  static async getProjectByIdOrSlug(e) {
+    return N.findOne({
+      where: {
+        [We.or]: [{ id: e }, { slug: e }]
+      }
+    });
+  }
+}
+N.init(
+  {
+    id: {
+      type: k.UUID,
+      defaultValue: k.UUIDV4,
+      primaryKey: !0
+    },
+    name: {
+      type: k.STRING,
+      allowNull: !1
+    },
+    description: k.TEXT,
+    createdAt: k.DATE,
+    updatedAt: k.DATE,
+    createdBy: {
+      type: k.STRING,
+      allowNull: !1
+    },
+    updatedBy: {
+      type: k.STRING,
+      allowNull: !1
+    },
+    slug: k.STRING,
+    icon: k.STRING,
+    pinnedAt: k.DATE,
+    useAllResources: k.BOOLEAN,
+    npmSecret: k.STRING,
+    relatedBlocklets: {
+      type: k.JSON,
+      allowNull: !1,
+      defaultValue: {},
+      get() {
+        const t = this.getDataValue("relatedBlocklets");
+        try {
+          return t ? JSON.parse(t) : {};
+        } catch (e) {
+          return f.error("Failed to parse relatedBlocklets", { error: e, rawValue: t }), {};
+        }
+      },
+      set(t) {
+        try {
+          this.setDataValue("relatedBlocklets", t ? JSON.stringify(t) : "{}");
+        } catch (e) {
+          f.error("Failed to set relatedBlocklets", { error: e, value: t }), this.setDataValue("relatedBlocklets", "{}");
+        }
+      }
+    },
+    productionState: {
+      type: k.JSON,
+      allowNull: !1,
+      defaultValue: {},
+      get() {
+        const t = this.getDataValue("productionState");
+        try {
+          return t ? JSON.parse(t) : {};
+        } catch (e) {
+          return f.error("Failed to parse productionState", { error: e, rawValue: t }), {};
+        }
+      },
+      set(t) {
+        try {
+          this.setDataValue("productionState", t ? JSON.stringify(t) : "{}");
+        } catch (e) {
+          f.error("Failed to set productionState", { error: e, value: t }), this.setDataValue("productionState", "{}");
+        }
+      }
+    }
+  },
+  { sequelize: U, paranoid: !0 }
+);
+N.hasMany(Oe, {
+  foreignKey: "projectId",
+  as: "components"
+});
+const no = eo, ro = to, ne = 30 * 24 * 60 * 60 * 1e3, ao = 24 * 60 * 60 * 1e3, qe = async (t = "") => {
+  const e = P(no, t);
+  try {
+    if (!(await M.stat(e)).isDirectory())
+      throw new Error(`${e} is not a directory`);
+  } catch {
+    await M.mkdir(e, { recursive: !0 });
+  }
+  return e;
+}, Le = (t, ...e) => t.keyGenerator ? t.keyGenerator(...e) : JSON.stringify([t.subdir || "", ...e]), io = (t, e) => {
+  const o = bt("md5").update(e).digest("hex");
+  return P(t, `${ro}-${o}.json`);
+}, co = async (t = "") => {
+  const e = await qe(t), o = Date.now();
+  try {
+    const s = await M.readdir(e);
+    await Promise.all(
+      s.filter((n) => n.endsWith(".json")).map(async (n) => {
+        const r = P(e, n);
+        try {
+          const c = await M.readFile(r, "utf-8"), a = JSON.parse(c);
+          a.createdAt && o - a.createdAt > ne && await M.unlink(r);
+        } catch {
+          try {
+            const a = await M.stat(r);
+            o - a.mtimeMs > ne && await M.unlink(r);
+          } catch {
+          }
+        }
+      })
+    );
+  } catch (s) {
+    console.error(`Failed to cleanup cache in ${e}:`, s);
+  }
+}, po = (() => {
+  const t = /* @__PURE__ */ new Set();
+  return setInterval(async () => {
+    await Promise.all(Array.from(t).map((s) => co(s)));
+  }, ao).unref(), (s) => {
+    t.add(s);
+  };
+})();
+function ue(t, e) {
+  return e.subdir && po(e.subdir), gt(
+    async (...s) => {
+      const n = await qe(e.subdir || ""), r = Le(e, ...s), c = io(n, r);
+      try {
+        const a = await M.readFile(c, "utf-8"), { value: l, createdAt: d } = JSON.parse(a);
+        if (d && Date.now() - d > ne)
+          throw await M.unlink(c).catch(() => {
+          }), new Error("Cache expired");
+        return l;
+      } catch {
+        const l = await t(...s), d = JSON.stringify({ value: l, createdAt: Date.now() });
+        return M.writeFile(c, d, "utf-8").catch((I) => {
+          console.error("Failed to write fs cache:", I);
+        }), l;
+      }
+    },
+    {
+      keyGenerator: (...s) => Le(e, ...s),
+      lruOptions: e.lruOptions || {
+        max: 100,
+        ttl: ne
+      }
+    }
+  );
+}
+const Qe = async () => await import("typescript"), lo = async () => await import("esbuild"), uo = async () => (await import("postcss")).default, fo = async () => (await import("tailwindcss")).default, mo = async () => (await import("autoprefixer")).default, ho = async (t, { componentId: e }) => {
+  const o = `@tailwind components;
+@tailwind utilities;
+`, s = `.CustomComponent_${e}`, n = await uo(), r = await fo(), c = await mo();
+  return (await n([
+    r({ content: [{ raw: t, extension: "tsx" }] }),
+    c({
+      overrideBrowserslist: ["> 1%", "last 2 versions"],
+      stats: {}
+    }),
+    (l) => {
+      l.walkRules((d) => {
+        d.selectors = d.selectors.map((I) => I.replace(/\.(.+)/g, `${s}.$1,${s} .$1`));
+      });
+    }
+    // FIXME: cssnano use browserslist, it is not working with the fs isolation
+    // cssnano({ preset: 'default' }),
+  ]).process(o)).css;
+}, go = async (t, { componentId: e }) => {
+  const o = await ho(t, { componentId: e });
+  return `export const __PagesKit_CSS__ = ${JSON.stringify(o)};
+
+${t}
+`;
+}, Ne = ue(
+  async (t, e) => {
+    const o = await Qe();
+    let s = o.transpileModule(t, {
+      compilerOptions: {
+        jsx: o.JsxEmit.React,
+        target: o.ScriptTarget.ES2016,
+        module: o.ModuleKind.ESNext
+      },
+      transformers: {
+        before: [Dt(o)]
+      }
+    }).outputText;
+    if (e.tailwind && (s = await go(s, { componentId: e.componentId })), e.module === Ie.ESM) return s;
+    const n = o.transpileModule(s, {
+      compilerOptions: {
+        jsx: o.JsxEmit.React,
+        target: o.ScriptTarget.ES2016,
+        module: o.ModuleKind.CommonJS,
+        moduleResolution: o.ModuleResolutionKind.Node16
+      }
+    }).outputText;
+    return e.module === Ie.CJS ? n : wo(e.moduleName, n);
+  },
+  {
+    subdir: "transpileModule"
+  }
+), yo = async (t, e) => {
+  const { build: o } = await lo(), n = (await o({
+    entryPoints: ["index.tsx"],
+    external: Object.keys(Ee),
+    format: "esm",
+    target: "esnext",
+    bundle: !0,
+    write: !1,
+    plugins: [
+      {
+        name: "vfs",
+        setup(l) {
+          let d = null;
+          l.onResolve({ filter: /.*/ }, (I) => I.path === "index.tsx" ? { path: "index.tsx", namespace: "vfs" } : I.path === "./component" ? { path: "component.tsx", namespace: "vfs" } : null), l.onLoad({ filter: /.*/, namespace: "vfs" }, async (I) => {
+            if (I.path === "index.tsx")
+              return { contents: `export { ${e} } from './component'`, loader: "tsx" };
+            if (I.path === "component.tsx")
+              return { contents: t, loader: "tsx" };
+            if (kt(I.path)) {
+              const h = I.path.split("/").pop();
+              if (d || (d = await Qo({ ensureLoaded: !1 })), d?.chunks?.[h])
+                try {
+                  const S = J(d.chunks[h], "utf-8");
+                  return f.info("get chunk from local file system", h), { contents: S, loader: "tsx" };
+                } catch {
+                }
+            }
+            return null;
+          });
+        }
+      }
+    ]
+  })).outputFiles?.[0]?.contents;
+  if (!n) throw new Error("Failed to build server code");
+  const r = Buffer.from(n).toString(), c = await Qe();
+  return c.transpileModule(r, {
+    compilerOptions: { module: c.ModuleKind.ESNext, target: c.ScriptTarget.ES2020 }
+  }).outputText;
+}, So = (t, e) => new RegExp(
+  `export\\s+\\{[^}]*(?:\\w+\\s+as\\s+${e}\\b|\\b${e}\\b)[^}]*\\}`,
+  "m"
+).test(t) ? t : void 0, Xe = ue(
+  async (t, e) => {
+    const o = await yo(t, e);
+    return So(o, e);
+  },
+  {
+    subdir: "extractExportValueSchema"
+  }
+), wo = (t, e) => `// GENERATED FILE. DO NOT EDIT.
+var ${t} = async function () {
+
+  const exports = {};
+  let moduleExports = null;
+  
+  // add commonjs module compatibility layer
+  const module = { exports: moduleExports };
+  
+  // execute component code
+  ${e}
+  
+  // handle possible module.exports
+  if (module.exports && module.exports !== moduleExports) {
+    // if module.exports is used, use it first
+    return typeof module.exports === 'object' ? module.exports : { default: module.exports };
+  }
+  
+  // ensure a default export
+  if (!('default' in exports) && Object.keys(exports).length === 0) {
+    // module has no exports, return null to indicate invalid
+    return null;
+  }
+  
+  return exports;
+};
+`, Ze = async () => {
+  const { Sandbox: t } = await import("@blocklet/quickjs");
+  return t;
+};
+function Io(t) {
+  return t?.type === "react-component";
+}
+const q = new le({
+  max: 100,
+  ttl: 1e3 * 60 * 60 * 24
+  // 24 hours
+}), Eo = 60 * 60, _e = 10;
+function bo(t) {
+  f.info("clear preload components cache", { cacheKey: t }), q.delete(t);
+}
+function Po(t) {
+  for (const e of q.keys())
+    e.includes(t) && (f.info("clear preload components cache", { cacheKey: e }), bo(e));
+}
+function Ao({
+  mode: t,
+  instanceId: e,
+  componentId: o,
+  locale: s
+}) {
+  return ["getPreloadComponents", t, e, o, s].join("-");
+}
+async function Us({
+  mode: t,
+  req: e,
+  state: o,
+  locale: s,
+  instances: n,
+  module: r
+}) {
+  const {
+    supportedLocales: c,
+    config: { defaultLocale: a }
+  } = o;
+  if (!a) return null;
+  const l = (await Promise.all(
+    n.map(async (p) => {
+      try {
+        const i = Ao({
+          mode: t,
+          instanceId: p.id,
+          componentId: p.componentId,
+          locale: s
+        });
+        if (t !== "draft" && p.useCache && q.has(i))
+          return f.info(`get preload component from cache: ${i}`), q.get(i);
+        const y = re({ state: o, componentId: p.componentId });
+        if (!y) return null;
+        const A = await Co({
+          req: e,
+          state: o,
+          componentId: y.id,
+          locale: s,
+          defaultLocale: a,
+          properties: p.properties
+        });
+        if (!A) return null;
+        const g = { instanceId: p.id, preload: A };
+        if (t !== "draft" && p.useCache) {
+          let m = Eo;
+          p.cacheDuration && (m = p.cacheDuration), f.info(`set preload component to cache(${m}s): ${i}`), q.set(i, g, {
+            ttl: m * 1e3
+          });
+        }
+        return g;
+      } catch (i) {
+        return f.error("get preload component error", { instanceId: p.id, componentId: p.componentId }, { error: i }), null;
+      }
+    })
+  )).filter((p) => !!p), d = Object.values(
+    l.reduce((p, i) => ({ ...p, ...i.preload.components }), {})
+  );
+  async function I() {
+    const p = await Promise.all(
+      d.map(async (i) => {
+        const y = ft({ componentId: i.component.id }), A = r === Ie.ESM ? {
+          module: r,
+          script: await Ne(i.script, {
+            componentId: i.component.id,
+            module: r,
+            tailwind: t !== "draft"
+          })
+        } : {
+          module: r,
+          script: await Ne(i.script, {
+            componentId: i.component.id,
+            module: r,
+            moduleName: y,
+            tailwind: t !== "draft"
+          }),
+          moduleName: y
+        };
+        return [i.component.id, { component: i.component, script: A }];
+      })
+    );
+    return Object.fromEntries(p);
+  }
+  const h = await I();
+  return {
+    config: { defaultLocale: a, supportedLocales: c },
+    components: h,
+    instances: l.map((p) => ({
+      id: p.instanceId,
+      componentId: p.preload.component.id,
+      locales: { [p.preload.locale]: { props: p.preload.props } }
+    }))
+  };
+}
+async function Co({
+  req: t,
+  state: e,
+  componentId: o,
+  locale: s,
+  defaultLocale: n,
+  properties: r
+}) {
+  const { supportedLocales: c } = e, a = re({ state: e, componentId: o });
+  if (!a) return null;
+  const l = c.some((I) => I.locale === s) ? s : n;
+  if (!l) return null;
+  const d = await et({ req: t, state: e, componentId: o, locale: l, defaultLocale: n, properties: r });
+  return d ? {
+    component: a,
+    ...d
+  } : null;
+}
+const Oo = 20;
+async function et({
+  req: t,
+  depth: e = 0,
+  state: o,
+  componentId: s,
+  locale: n,
+  defaultLocale: r,
+  properties: c
+}) {
+  if (e > Oo) throw new RangeError("max component depth exceeded");
+  const a = vo({ state: o, componentId: s, properties: c, locale: n });
+  if (!a) return null;
+  const { props: l, component: d } = a, I = {
+    locale: n || r,
+    components: { [a.component.id]: { component: a.component, script: a.script } },
+    props: { ...l }
+  };
+  try {
+    const h = Io(d.renderer) ? d.renderer.getServerSideProps : void 0, S = await To({ ...a, req: t, serverSideProps: h });
+    S?.props && Object.assign(I.props, S.props);
+  } catch (h) {
+    f.error("preload data at server side error", { componentId: s, name: a.component.name }, { error: h });
+  }
+  return await Promise.all(
+    Object.entries(l).map(async ([h, S]) => {
+      if (S?.type === ke) {
+        const p = await et({
+          req: t,
+          depth: e + 1,
+          state: o,
+          componentId: S.componentId,
+          locale: n,
+          defaultLocale: r,
+          properties: S.properties
+        });
+        p && (Object.assign(I.components, p.components), Object.assign(I.props, {
+          [h]: {
+            type: ke,
+            componentId: S.componentId,
+            props: p.props
+          }
+        }));
+      }
+    })
+  ), I;
+}
+function vo({
+  state: t,
+  componentId: e,
+  locale: o,
+  properties: s
+}) {
+  const n = re({ state: t, componentId: e });
+  if (!n) return null;
+  const r = mt({
+    componentId: e,
+    getComponent: (c) => re({ state: t, componentId: c }),
+    locale: o,
+    defaultLocale: t.config.defaultLocale,
+    properties: s
+  });
+  return r ? { component: n, script: r.script, props: { locale: o, ...r.props } } : null;
+}
+function re({ state: t, componentId: e }) {
+  return t.components[e]?.data ?? t.resources.components?.[e]?.component;
+}
+async function To({
+  component: t,
+  script: e,
+  props: o,
+  req: s,
+  serverSideProps: n
+}) {
+  if (!n && !e?.includes("getServerSideProps"))
+    return null;
+  const r = n ?? await Xe(e, "getServerSideProps");
+  if (!r) return null;
+  const a = (r.match(/export\s*{\s*(\w+)\s+as\s+getServerSideProps\s*}/) || r.match(/export\s*{\s*getServerSideProps\s*}/))?.[1] || "getServerSideProps", l = new Promise((h) => {
+    setTimeout(() => {
+      h({});
+    }, _e * 1e3);
+  }), d = await Ze();
+  return await Promise.race([
+    l,
+    d.callFunction({
+      code: `${r}
+
+export async function getServerSidePropsWrapper(props) {
+  const { location, fetch, props: componentProps } = props;
+  // 使用局部变量而不是全局变量
+  const originalLocation = typeof window !== 'undefined' ? window.location : undefined;
+  const originalFetch = globalThis.fetch;
+  
+  try {
+    globalThis.location = location;
+    globalThis.fetch = fetch;
+    return await ${a}(componentProps);
+  } finally {
+    // 清理全局状态
+    if (originalLocation) globalThis.location = originalLocation;
+    if (originalFetch) globalThis.fetch = originalFetch;
+  }
+}`,
+      filename: `${t.name || t.id}.js`,
+      moduleLoader: (h) => {
+        if (h === "@blocklet/pages-kit/builtin/utils")
+          return `            const { joinURL, withQuery, getQuery, getComponentMountPoint } = globalThis
+            export { joinURL, withQuery, getQuery, getComponentMountPoint }
+          `;
+        if (h === "@blocklet/pages-kit/builtin/dayjs")
+          return ge.dayjs;
+        if (h in ge)
+          return ge[h];
+        if (h in Ee) {
+          const S = Ee[h];
+          return Pe(S) ? void 0 : S;
+        }
+      },
+      global: {
+        console: {
+          // NOTE: do not return logger.xxx result, it will cause memory leak
+          // eslint-disable-next-line prettier/prettier
+          log: (...h) => {
+            f.info(...h);
+          },
+          warn: (...h) => {
+            f.warn(...h);
+          },
+          error: (...h) => {
+            f.error(...h);
+          }
+        },
+        getComponentMountPoint: dt,
+        joinURL: V,
+        withQuery: It,
+        getQuery: wt
+      },
+      functionName: "getServerSidePropsWrapper",
+      args: [
+        {
+          // NOTE: IMPORTANT! place location and fetch (has side effect) at the args not global
+          // because the global is shared between all runtime and just init once
+          location: { href: V(Et(s.hostname), s.originalUrl) },
+          fetch: (h, { ...S } = {}) => {
+            const p = typeof h == "string" && h.startsWith("/") ? V(E.env.appUrl, h) : h;
+            if (typeof p == "string" && De(p).host === De(E.env.appUrl).host) {
+              const i = s.get("cookie");
+              if (i) {
+                const y = new St(S.headers);
+                y.set("cookie", i), S.headers = y;
+              }
+            }
+            return yt(p, {
+              ...S,
+              timeout: _e * 1e3
+            }).then((i) => ({
+              ok: i.ok,
+              status: i.status,
+              statusText: i.statusText,
+              headers: Object.fromEntries(i.headers.entries()),
+              json: () => i.json()
+            }));
+          },
+          props: o
+        }
+      ]
+    })
+  ]);
+}
+const ko = ue(
+  async (t, e, o, s) => {
+    if (!t?.includes(e) && !s)
+      return null;
+    const n = s ?? await Xe(t, e);
+    if (n)
+      try {
+        return await (await Ze()).callFunction({
+          code: `
+            ${n}
+
+            export function get${e}SchemaWrapper() {
+              return ${e};
+            }
+          `,
+          filename: `${o}.js`,
+          functionName: `get${e}SchemaWrapper`
+        });
+      } catch (r) {
+        return f.error(`获取 ${e} 失败`, { componentId: o, error: r }), null;
+      }
+    return null;
+  },
+  {
+    subdir: "getExportSchemaValueFromCode"
+  }
+), Do = "z8iZiDFg3vkkrPwsiba1TLXy3H9XHzFERsP8o", Ue = "page", Fe = "trigger-reload-project-resource", tt = Do, Ro = "z2qa7BQdkEb3TwYyEYC1psK6uvmGnHSUHt5RM";
+function ae(t) {
+  t.observeDeep((e) => {
+    e.some((o) => o.changes.keys.has("updatedAt") || o.changes.keys.has("publishedAt")) || t.set("updatedAt", (/* @__PURE__ */ new Date()).toISOString());
+  });
+}
+function ot() {
+  return Pt(P(E.env.dataDir, "tmp-"));
+}
+function ie(t, e, o = []) {
+  return Array.isArray(t) ? t.flatMap((s, n) => ie(s, e, [...o, n])) : typeof t == "object" ? t === null ? [] : Object.entries(t).flatMap(([s, n]) => ie(n, e, [...o, s])) : e(t) ? [o] : [];
+}
+function R(t) {
+  return t.filter((e) => e != null);
+}
+function xo(t) {
+  t.pages && Object.keys(t.pages).forEach((o) => {
+    const s = z(t.pages[o]);
+    s && s instanceof _.Map && ae(s);
+  });
+  const e = z(t.pages);
+  e && e instanceof _.Map && e.observe((o) => {
+    o.changes.keys.forEach((s, n) => {
+      if (s.action === "add") {
+        const r = z(t.pages[n]);
+        r && r instanceof _.Map && ae(r);
+      }
+    });
+  });
+}
+function jo(t) {
+  t.routes && Object.keys(t.routes).forEach((o) => {
+    const s = z(t.routes?.[o]);
+    s && s instanceof _.Map && ae(s);
+  });
+  const e = z(t.routes);
+  e && e instanceof _.Map && e.observe((o) => {
+    o.changes.keys.forEach((s, n) => {
+      if (s.action === "add") {
+        const r = z(t.routes?.[n]);
+        r && r instanceof _.Map && ae(r);
+      }
+    });
+  });
+}
+function $o(t, e) {
+  for (const o of e || Object.keys(t.routes || {})) {
+    let s = o, n = [];
+    if (o.includes("-")) {
+      const [r, ...c] = o.split("-");
+      s = r, n = c || [];
+    }
+    if (t.routes?.[s] !== void 0) {
+      t.routes[s].publishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const r = t.routes[s];
+      if (!r || !r.params || r.params.length === 0)
+        continue;
+      if (o.includes("-") && n.length > 0) {
+        const c = Lt(n, r);
+        c && (c.publishedAt = (/* @__PURE__ */ new Date()).toISOString());
+      }
+      if (!e) {
+        const c = Ae({
+          basePath: r.path,
+          params: r.params,
+          routeId: r.id,
+          paramsOptions: r.paramsOptions,
+          currentIndex: 0,
+          currentParams: [],
+          currentOptionIds: [],
+          result: []
+        });
+        for (const a of c)
+          a.routeMetaData ??= {}, a.routeMetaData.publishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    }
+  }
+}
+function Se({
+  page: t,
+  route: e,
+  state: o,
+  routeId: s,
+  routePathInfo: n
+}) {
+  f.info(
+    `Executing datasource data assembly, routeId: ${s}, routePathInfo: ${JSON.stringify(n)}`
+  );
+  const r = {
+    ...Nt(t),
+    id: s,
+    slug: n?.path ?? e.path,
+    createdAt: e.createdAt,
+    updatedAt: n?.routeMetaData?.updatedAt ?? e.updatedAt,
+    publishedAt: n?.routeMetaData?.publishedAt ?? e.publishedAt,
+    isPublic: (n?.routeMetaData?.isPublic ?? e.isPublic) && e.isPublic
+  };
+  for (const c of o.supportedLocales) {
+    if (e.dataSource) {
+      let a = e.id;
+      n && (a = n.paramOptionIds.join("-"));
+      const l = e.dataSource.pathDataMappings?.[a]?.dataCache?.[c.locale] ?? e.dataSource.pathDataMappings?.[a]?.dataCache?.[o.config.defaultLocale || "en"];
+      if (!l)
+        continue;
+      Mt(r, o, c.locale, l);
+    }
+    n && n.routeMetaData && (n.routeMetaData.publishedAt = (/* @__PURE__ */ new Date()).toISOString());
+  }
+  return r;
+}
+const H = new le({
+  max: 100,
+  ttl: 10 * 60 * 1e3
+  // 10 minutes
+});
+function Mo(t, e = []) {
+  let o = 0;
+  const s = Array.from(H.keys()), n = [];
+  for (const r of t) {
+    n.push(`page-html:prod:${r}:lang-path=none`);
+    for (const c of e)
+      n.push(`page-html:prod:/${c}${r}:lang-path=${c}`);
+  }
+  for (const r of s) {
+    const c = r.split(":lang-path=")[0] || "";
+    for (const a of n) {
+      const d = (a.split(":lang-path=")[0] || "").replace(/\/:[^/]+/g, "");
+      if (c.startsWith(d)) {
+        H.delete(r), o++, f.info(`[Cache CLEAR] key: ${r}`);
+        break;
+      }
+    }
+  }
+  return f.info(`[Cache CLEAR] cleared ${o} entries for patterns:`, n), o;
+}
+function Lo({
+  projectId: t,
+  projectSlug: e,
+  supportedLocales: o = []
+}) {
+  let s = 0;
+  const n = Array.from(H.keys()), r = [];
+  r.push(`page-html:prod:/${t}`), e && e !== t && r.push(`page-html:prod:/${e}`);
+  for (const c of o)
+    r.push(`page-html:prod:/${c}/${t}`), e && e !== t && (e !== "/" ? r.push(`page-html:prod:/${c}/${e}`) : r.push(`page-html:prod:/${c}`));
+  for (const c of n)
+    for (const a of r)
+      if (c.startsWith(a)) {
+        H.delete(c), s++, f.info(`[Cache CLEAR PROJECT] key: ${c}`);
+        break;
+      }
+  return f.info(
+    `[Cache CLEAR PROJECT] cleared ${s} entries for project ${t}${e ? ` (slug: ${e})` : ""}`
+  ), s;
+}
+function No() {
+  const t = H.size;
+  return H.clear(), f.info(`[Cache CLEAR ALL] cleared ${t} entries`), t;
+}
+E.events.on(E.Events.envUpdate, No);
+const { uploadToMediaKit: _o } = require("@blocklet/uploader-server"), ve = /^\w+(\w|-|\.)+\w+\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm)$/, Q = /mediakit:\/\/([a-f0-9]{32}\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm))/i, Be = /mediakit:\/\/([a-f0-9]{32}\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm))/gi, Uo = 1e4, Fo = 3e4, Z = 0, we = 1, Bo = 0, Vo = 1, st = E, ee = P(process.env.BLOCKLET_DATA_DIR, "site-state");
+function ce(t) {
+  return t?.replace(/\//g, "|") || "";
+}
+function Go() {
+  const t = st.env.languages.map((o) => ({ locale: o.code, name: o.name })), e = t[0]?.locale;
+  return {
+    pageIds: [],
+    pages: {},
+    routeIds: [],
+    routes: {},
+    dataSourceIds: [],
+    dataSources: {},
+    components: {},
+    supportedLocales: t,
+    config: { defaultLocale: e },
+    resources: {}
+  };
+}
+class v extends _.Doc {
+  constructor(e) {
+    super(), this.options = e, L(this.draftYjsFilePath) && _.applyUpdate(this, J(this.draftYjsFilePath)), this.syncedStore = Ut(
+      $t(
+        {
+          pages: {},
+          pageIds: [],
+          components: {},
+          supportedLocales: [],
+          config: {},
+          resources: {},
+          routeIds: [],
+          routes: {},
+          dataSourceIds: [],
+          dataSources: {}
+        },
+        this
+      )
+    ), this.initObserver(), this.on("update", this.updateHandler), this.awareness = new Ht(this), this.awareness.on("update", this.awarenessChangeHandler), this.ensureDataStructure();
+  }
+  // 延迟释放时间：5 分钟
+  static RELEASE_DELAY = 5 * 60 * 1e3;
+  // 定期检查间隔：2 小时
+  static PERIODIC_CHECK_INTERVAL = 2 * 60 * 60 * 1e3;
+  // 2 hours
+  static sharedInstances = {};
+  static pageUrlMapCache = new le({
+    max: 100,
+    ttl: 1e3 * 60 * 60 * 24
+    // 1 day
+  });
+  // 定期检查定时器
+  static periodicCheckTimer;
+  // safe delete project state dir
+  static safeDeleteProjectStateDir(e) {
+    if (!e)
+      throw new Error("Should provide project context");
+    try {
+      const o = P(ee, e), s = P(ee, `@del-${e}`);
+      Re(o, s);
+    } catch (o) {
+      f.error("Failed to safe delete project state dir:", o);
+    }
+  }
+  static async getProjectIds() {
+    return (await N.findAll({ attributes: ["id"], raw: !0 })).map((e) => e.id);
+  }
+  /** @deprecated 不再使用这个 getter 了，仅作为兼容性处理，请使用 getProjectIds 代替 */
+  static get projectIds() {
+    return se("*/", {
+      cwd: ee,
+      ignore: ["@del-*", "@tmp-*", ".*", "staging", "production", "@backup-*", "undefined"]
+      // Ignore temp directories and hidden files
+    });
+  }
+  /** @deprecated 不再使用这个 getter 了，仅作为兼容性处理 */
+  static get allShared() {
+    return this.projectIds.map((e) => v.shared(e));
+  }
+  static shared(e) {
+    if (!e)
+      throw new Error("Should provide project context");
+    let o = v.sharedInstances[e];
+    return o || (o = new v({
+      path: P(ee, e)
+    }), v.sharedInstances[e] = o, lt({
+      projectId: e,
+      pages: de,
+      components: fe
+    }), o);
+  }
+  // 轻量级 production 状态获取，不加载 draft 数据
+  static async getProductionState(e) {
+    return (await N.findByPk(e, {
+      attributes: ["productionState"]
+    }))?.productionState ?? Go();
+  }
+  destroy() {
+    this.cancelRelease(), this.save({ flush: !0 }), this.conns.forEach((o, s) => this.closeConn(s)), this.awareness.destroy();
+    const e = x(this.options.path);
+    delete v.sharedInstances[e], super.destroy();
+  }
+  initObserver() {
+    xo(this.syncedStore), jo(this.syncedStore);
+  }
+  get draftYjsFilePath() {
+    return P(this.options.path, "draft.yjs");
+  }
+  static async getStateByProjectId(e, o) {
+    if (o === "draft") {
+      const s = v.shared(e);
+      return JSON.parse(JSON.stringify(s.syncedStore));
+    }
+    return v.getProductionState(e);
+  }
+  async getState(e) {
+    if (e === "draft")
+      return JSON.parse(JSON.stringify(this.syncedStore));
+    const o = x(this.options.path);
+    return v.getProductionState(o);
+  }
+  async setState(e, o) {
+    const s = await Ho(o, { exportAssets: !1, includeResources: !0 }), n = this.getPublishDir(e);
+    if (F(j(n), { recursive: !0 }), Je(n, { force: !0, recursive: !0 }), Re(s, n), e === "production") {
+      const r = x(this.options.path);
+      v.pageUrlMapCache.delete(r), await N.update({ productionState: o }, { where: { id: r } });
+    }
+  }
+  getPublishDir(e) {
+    return P(this.options.path, e);
+  }
+  syncedStore;
+  conns = /* @__PURE__ */ new Map();
+  awareness;
+  // 延迟释放定时器
+  releaseTimer;
+  awarenessChangeHandler = ({ added: e, updated: o, removed: s }, n) => {
+    const r = e.concat(o, s);
+    if (n !== null) {
+      const l = this.conns.get(n);
+      l && (e.forEach((d) => {
+        l.add(d);
+      }), s.forEach((d) => {
+        l.delete(d);
+      }));
+    }
+    const c = D.createEncoder();
+    D.writeVarUint(c, we), D.writeVarUint8Array(c, $e(this.awareness, r));
+    const a = D.toUint8Array(c);
+    this.conns.forEach((l, d) => this.send(d, a));
+  };
+  updateHandler = (e) => {
+    const o = D.createEncoder();
+    D.writeVarUint(o, Z), qt(o, e);
+    const s = D.toUint8Array(o);
+    this.conns.forEach((n, r) => this.send(r, s));
+  };
+  ensureDataStructure = () => {
+    const { supportedLocales: e, pages: o, pageIds: s, config: n, routes: r, routeIds: c } = this.syncedStore;
+    {
+      const a = new Set(Object.keys(o));
+      let l = 0;
+      for (; l < s.length; ) {
+        const d = s[l];
+        a.has(d) ? (a.delete(d), l++) : s.splice(l, 1);
+      }
+    }
+    {
+      const a = new Set(Object.keys(r));
+      let l = 0;
+      for (; l < c.length; ) {
+        const d = c[l];
+        a.has(d) ? (a.delete(d), l++) : c.splice(l, 1);
+      }
+    }
+    e.splice(0, e.length), e.push(...st.env.languages.map((a) => ({ locale: a.code, name: a.name }))), n.defaultLocale = e[0]?.locale;
+    {
+      let a = 0;
+      const l = /* @__PURE__ */ new Set();
+      for (; a < e.length; ) {
+        const { locale: d } = e[a];
+        l.has(d) ? e.splice(a, 1) : (a++, l.add(d));
+      }
+    }
+  };
+  send = (e, o) => {
+    e.readyState !== Bo && e.readyState !== Vo && this.closeConn(e);
+    try {
+      e.send(o, (s) => {
+        s && this.closeConn(e);
+      });
+    } catch {
+      this.closeConn(e);
+    }
+  };
+  closeConn = (e) => {
+    if (e.removeAllListeners(), this.conns.has(e)) {
+      const o = this.conns.get(e);
+      this.conns.delete(e), o && Wt(this.awareness, Array.from(o), null);
+    }
+    e.close(), this.checkAndScheduleRelease();
+  };
+  // 检查并调度延迟释放
+  checkAndScheduleRelease() {
+    this.conns.size === 0 && this.scheduleRelease();
+  }
+  // 调度延迟释放
+  scheduleRelease() {
+    this.cancelRelease();
+    const e = x(this.options.path);
+    this.releaseTimer = setTimeout(() => {
+      f.info(`[SiteState] releasing instance due to no active connections: ${e}`), this.conns.size === 0 && (this.releaseTimer = void 0, this.destroy());
+    }, v.RELEASE_DELAY), f.info(`[SiteState] scheduled release for project ${e} in ${v.RELEASE_DELAY / 1e3}s`);
+  }
+  // 取消延迟释放
+  cancelRelease() {
+    if (this.releaseTimer) {
+      clearTimeout(this.releaseTimer), this.releaseTimer = void 0;
+      const e = x(this.options.path);
+      f.info(`[SiteState] cancelled scheduled release for project ${e}`);
+    }
+  }
+  autoSave = ze(() => {
+    F(j(this.draftYjsFilePath), { recursive: !0 }), oe(this.draftYjsFilePath, _.encodeStateAsUpdate(this));
+  }, Uo);
+  save = ({ flush: e = !1 } = {}) => {
+    this.autoSave(), e && this.autoSave.flush();
+  };
+  publish = async ({ mode: e, routes: o }) => {
+    const s = await this.getState("draft"), n = await this.getState("production");
+    await Ge(s, n, { routes: o, mergeMode: "replace", deleteRoutes: !0, publishMode: e }), n.config.publishedAt = (/* @__PURE__ */ new Date()).getTime(), $o(this.syncedStore, o), await this.setState(e, n), await this.clearPageCacheForRoutes(o, n);
+  };
+  mergeState = async (e, o) => {
+    const s = JSON.parse(JSON.stringify(o));
+    e.config.fontFamily ??= {};
+    const n = s.config?.fontFamily, r = e.config?.fontFamily;
+    e.config.fontFamily.title = n?.title || r?.title, e.config.fontFamily.description = n?.description || r?.description, await new Promise((c, a) => {
+      this.transact(async () => {
+        try {
+          const l = await Ge(e, o);
+          c(l);
+        } catch (l) {
+          a(l);
+        }
+      });
+    });
+  };
+  clearPageCacheForRoutes = async (e, o) => {
+    const s = x(this.options.path), r = (await N.findByPk(s))?.slug || s;
+    if (f.info(`[SiteState] clearing page cache for project ${s}, routes:`, e || []), !e || e.length === 0) {
+      Lo({
+        projectId: s,
+        projectSlug: r,
+        supportedLocales: o.supportedLocales.map((d) => d.locale)
+      });
+      return;
+    }
+    const c = o.supportedLocales.map((d) => d.locale), a = [], l = e.filter((d) => o.pages[d]);
+    for (const d of l) {
+      const h = o.pages[d].slug;
+      r && r !== s && (r === "/" ? a.push(h) : a.push(`/${r}${h}`)), a.push(`/${s}${h}`);
+    }
+    if (f.info(`[SiteState] clearing page cache for project ${s}, pathPatterns:`, a), a.length > 0) {
+      const d = Mo(a, c);
+      f.info(`[SiteState] cleared ${d} page cache entries for project ${s}, routes:`, e);
+    }
+  };
+  addConnection = (e) => {
+    if (this.conns.has(e))
+      return;
+    this.cancelRelease(), e.binaryType = "arraybuffer", this.conns.set(e, /* @__PURE__ */ new Set()), e.on("message", (n) => this.messageListener(e, new Uint8Array(n)));
+    let o = !0;
+    const s = setInterval(() => {
+      if (!o)
+        this.conns.has(e) && this.closeConn(e), clearInterval(s);
+      else if (this.conns.has(e)) {
+        o = !1;
+        try {
+          e.ping();
+        } catch {
+          this.closeConn(e), clearInterval(s);
+        }
+      }
+    }, Fo);
+    e.on("close", () => {
+      this.closeConn(e), clearInterval(s);
+    }), e.on("pong", () => {
+      o = !0;
+    });
+    {
+      const n = D.createEncoder();
+      D.writeVarUint(n, Z), Qt(n, this), this.send(e, D.toUint8Array(n));
+      const r = this.awareness.getStates();
+      if (r.size > 0) {
+        const c = D.createEncoder();
+        D.writeVarUint(c, we), D.writeVarUint8Array(c, $e(this.awareness, Array.from(r.keys()))), this.send(e, D.toUint8Array(c));
+      }
+    }
+  };
+  messageListener = (e, o) => {
+    try {
+      const s = D.createEncoder(), n = ye.createDecoder(o), r = ye.readVarUint(n);
+      switch (r) {
+        case Z:
+          D.writeVarUint(s, Z), Xt(n, s, this, null), D.length(s) > 1 && (this.ensureDataStructure(), this.send(e, D.toUint8Array(s)));
+          break;
+        case we: {
+          Yt(this.awareness, ye.readVarUint8Array(n), e);
+          break;
+        }
+        default:
+          f.warn(`Unsupported messageType ${r}`);
+      }
+    } catch (s) {
+      f.error(s);
+    }
+    this.save();
+  };
+  // 这个方法还是需要动态的，因为可能会动态修改 projectSlug、语言之类的
+  static async pageUrlMap(e, o) {
+    let s = [];
+    o ? s = [o] : s = await this.getProjectIds();
+    let n = {};
+    if (e === "production" && s?.length) {
+      const r = new Map(s.map((c) => [c, !0]));
+      for (const c of s) {
+        const a = v.pageUrlMapCache.get(c);
+        a && (n = { ...n, ...a }, r.delete(c));
+      }
+      s = Array.from(r.keys());
+    }
+    if (s?.length) {
+      const r = await N.findAll({
+        where: {
+          id: {
+            [We.in]: s
+          }
+        }
+      });
+      await Promise.all(
+        r.map(async (c) => {
+          const a = c.id, l = c.slug || a, d = {}, I = e === "production" && c?.productionState ? c.productionState : await v.getStateByProjectId(c.id, e), h = Bt(
+            E.env.languages.map((p) => p.code),
+            I.supportedLocales.map((p) => p.locale)
+          ), S = (p, i) => {
+            l && (d[V("/", l, p)] = {
+              ...i,
+              shouldRedirect: !0,
+              mainPage: !0
+            }), d[V("/", a, p)] = {
+              ...i,
+              shouldRedirect: !0,
+              mainPage: !0
+            };
+            for (const y of h) {
+              const A = { ...i, locale: y };
+              d[V("/", y, a, p)] = A, l && (d[V("/", y, l, p)] = A);
+            }
+          };
+          if (e === "draft")
+            for (const p of I.routeIds || []) {
+              const i = I?.routes?.[p];
+              if (!i) continue;
+              if (i.params && i.params.length > 0) {
+                const g = Ae({
+                  basePath: i.path,
+                  params: i.params,
+                  routeId: i.id,
+                  paramsOptions: i.paramsOptions,
+                  currentIndex: 0,
+                  currentParams: [],
+                  currentOptionIds: [],
+                  result: []
+                });
+                for (const m of g) {
+                  const w = m.path, C = {
+                    projectId: a,
+                    projectSlug: l,
+                    pageSlug: w,
+                    pageId: i.displayTemplateId || "",
+                    routeId: p,
+                    // default locale
+                    defaultLocale: h?.[0],
+                    locales: h,
+                    publishedAt: I.config.publishedAt,
+                    isPublic: i.isPublic && m?.routeMetaData?.isPublic
+                  };
+                  S(w, C);
+                }
+              }
+              const y = i.path, A = {
+                projectId: a,
+                projectSlug: l,
+                pageSlug: y,
+                pageId: i.displayTemplateId || "",
+                routeId: p,
+                // default locale
+                defaultLocale: h?.[0],
+                locales: h,
+                publishedAt: I.config.publishedAt,
+                isPublic: i.isPublic
+              };
+              S(y, A);
+            }
+          for (const p of I.pageIds) {
+            const i = I.pages[p];
+            if (!i || e === "production" && !i.isPublic)
+              continue;
+            const y = i.slug, A = c.slug || a, g = {
+              projectId: a,
+              projectSlug: A,
+              pageSlug: y,
+              pageId: p,
+              // default locale
+              defaultLocale: h?.[0],
+              locales: h,
+              publishedAt: I.config.publishedAt,
+              isPublic: i.isPublic,
+              templateConfig: i.templateConfig
+            };
+            S(y, g);
+          }
+          e === "production" && v.pageUrlMapCache.set(a, d), n = { ...n, ...d };
+        })
+      );
+    }
+    return n;
+  }
+  getDocumentSize() {
+    return _.encodeStateAsUpdate(this).byteLength;
+  }
+  static getInstancesSizeInfo() {
+    const e = [];
+    for (const [o, s] of Object.entries(v.sharedInstances)) {
+      const n = s.getDocumentSize();
+      e.push({
+        projectId: o,
+        sizeInBytes: n,
+        sizeInMB: `${(n / (1024 * 1024)).toFixed(2)} MB`,
+        activeConnections: s.conns.size
+      });
+    }
+    return e;
+  }
+  // 启动定期检查
+  static startPeriodicCheck() {
+    this.periodicCheckTimer || (this.periodicCheckTimer = setInterval(() => {
+      this.performPeriodicCheck();
+    }, this.PERIODIC_CHECK_INTERVAL), f.info(
+      `[SiteState] periodic check started, interval: ${this.PERIODIC_CHECK_INTERVAL / (60 * 60 * 1e3)} hours`
+    ));
+  }
+  // 停止定期检查
+  static stopPeriodicCheck() {
+    this.periodicCheckTimer && (clearInterval(this.periodicCheckTimer), this.periodicCheckTimer = void 0, f.info("[SiteState] periodic check stopped"));
+  }
+  // 执行定期检查
+  static performPeriodicCheck() {
+    const e = Object.keys(v.sharedInstances).length, o = [], s = [];
+    for (const [n, r] of Object.entries(v.sharedInstances))
+      r.conns.size === 0 ? o.push({ projectId: n, instance: r }) : s.push({ projectId: n, connections: r.conns.size });
+    if (f.info(
+      `[SiteState] periodic check summary: total instances: ${e}, with connections: ${s.length}, without connections: ${o.length}`
+    ), o.length > 0) {
+      f.info(
+        `[SiteState] releasing ${o.length} instances without connections:`,
+        o.map((r) => r.projectId)
+      );
+      let n = 0;
+      for (const { projectId: r, instance: c } of o)
+        try {
+          f.info(`[SiteState] releasing instance due to periodic check: ${r}`), c.destroy(), n++;
+        } catch (a) {
+          f.error(`[SiteState] failed to release instance ${r} during periodic check:`, a);
+        }
+      f.info(
+        `[SiteState] periodic check completed: ${n}/${o.length} instances released successfully`
+      );
+    } else e > 0 ? f.debug("[SiteState] periodic check: all instances have active connections") : f.debug("[SiteState] periodic check: no instances exist");
+  }
+}
+async function Jo(t, e, o) {
+  if (!t || !L(t) || !G(t).isFile())
+    return null;
+  let s = o[t];
+  return s || (s = (async () => {
+    try {
+      return (await _o({
+        filePath: t,
+        fileName: e
+      }))?.data?.filename;
+    } catch (n) {
+      return f.error(`Failed to upload asset ${t}:`, n), null;
+    }
+  })(), o[t] = s), s;
+}
+const Ko = async (t, e) => {
+  const o = x(t), s = await jt({
+    name: tt,
+    path: V("/uploads", o),
+    responseType: "stream",
+    method: "GET"
+  });
+  if (s.status >= 200 && s.status < 400) {
+    const n = Ot(e);
+    await Jt(s.data, n);
+  } else
+    throw new Error(`download asset failed ${s.status}`);
+}, zo = async (t, e) => {
+  await Promise.all(
+    t.map(async (o) => {
+      try {
+        await Ko(o, P(e, x(o)));
+      } catch (s) {
+        f.error(`Failed to export assets: ${o}, ${s}`);
+      }
+    })
+  );
+};
+function nt(t) {
+  return ve.test(t) ? [t] : Q.test(t) ? (Be.lastIndex = 0, Array.from(t.matchAll(Be)).map((o) => o[1]).filter((o) => !!o)) : [];
+}
+async function te(t, e, o) {
+  const { getFilename: s, exportAssets: n } = o, r = P(e, s(t));
+  if (F(j(r), { recursive: !0 }), oe(r, K.stringify(t)), n) {
+    const a = ie(
+      t,
+      (l) => typeof l == "string" && (ve.test(l) || Q.test(l))
+    ).map((l) => {
+      const d = Ce(t, l);
+      return nt(d);
+    }).flat().filter(Boolean);
+    await zo(a, j(r));
+  }
+}
+const be = new le({
+  max: 100,
+  ttl: 1 * 60 * 1e3
+  // 1 minute
+});
+async function Ve(t, e, o) {
+  const s = ie(
+    t,
+    (a) => typeof a == "string" && (ve.test(a) || Q.test(a))
+  ), n = Vt(2), r = s.map(
+    (a) => n(async () => {
+      try {
+        const l = Ce(t, a), d = nt(l);
+        for (const I of d) {
+          const h = x(I), S = o.getFilePath(I, a), p = S ? `${S}:${h}` : h, i = be.get(p);
+          if (i) {
+            Q.test(l) || je(t, a, i);
+            return;
+          }
+          const y = await Jo(S, h, e);
+          y && (Q.test(l) || je(t, a, y), be.set(p, y));
+        }
+      } catch (l) {
+        f.error(`Failed to process upload for path ${a.join(".")}:`, l.message || l.reason);
+      }
+    })
+  ), c = await Promise.allSettled(r);
+  o.onFinish?.(c);
+}
+async function Ho(t, {
+  exportAssets: e,
+  pageIds: o = "all",
+  componentIds: s = "all",
+  rawConfig: n,
+  includeResources: r = !1,
+  routeIds: c = "all"
+} = {}) {
+  const a = o === "all" ? t.pageIds : o, l = ht({
+    state: t,
+    pageIds: a,
+    componentIds: s === "all" ? Object.keys(t.components) : s
+  }), d = c === "all" ? t.routeIds : c, I = (u) => ({
+    id: u.id,
+    name: u.name,
+    isTemplateSection: u.isTemplateSection ?? !1,
+    templateDescription: u.templateDescription,
+    llmConfig: u.llmConfig,
+    component: u.component,
+    config: u.config,
+    visibility: u.visibility,
+    sections: u?.sectionIds ? R(
+      u?.sectionIds?.map((b) => {
+        const T = u.sections?.[b];
+        return T && I(T);
+      })
+    ) : void 0
+    // 已经废弃，数据在 page.dataSource 中管理
+    // properties: section.locales?.[locale] ?? {},
+  }), h = (u, b) => ({
+    id: u.id,
+    createdAt: u.createdAt,
+    updatedAt: u.updatedAt,
+    publishedAt: u.publishedAt,
+    isPublic: u.isPublic ?? !0,
+    templateConfig: u.templateConfig,
+    meta: u.locales?.[b] ?? {},
+    sections: R(
+      u.sectionIds.map((T) => {
+        const B = u.sections[T];
+        return B && I(B);
+      })
+    ),
+    // 将 dataSource.sectionId.locale 转换为 dataSource.sectionId
+    dataSource: Object.fromEntries(
+      Object.entries(u.dataSource || {}).map(([T, B]) => [T, B?.[b] ?? {}])
+    )
+  }), S = (u) => ({
+    id: u.id,
+    createdAt: u.createdAt,
+    updatedAt: u.updatedAt,
+    publishedAt: u.publishedAt,
+    path: u.path,
+    handler: u.handler,
+    isPublic: u.isPublic ?? !0,
+    params: u.params ?? [],
+    enabledGenerate: u.enabledGenerate ?? !1,
+    displayTemplateId: u.displayTemplateId,
+    dataSource: u.dataSource
+  }), p = R(
+    d.map((u) => {
+      const b = t.routes[u];
+      return b && S(b);
+    })
+  ), i = R(
+    t.supportedLocales.map((u) => u.locale).flatMap(
+      (u) => a.map((b) => {
+        const T = t.pages[b];
+        return T && {
+          locale: u,
+          slug: T.slug,
+          page: h(T, u)
+        };
+      })
+    )
+  ), y = ot(), A = P(y, "pages");
+  F(A, { recursive: !0 });
+  const g = P(y, "components");
+  F(g, { recursive: !0 });
+  const m = P(y, "routes");
+  F(m, { recursive: !0 });
+  for (const { locale: u, slug: b, page: T } of i)
+    await te(T, A, {
+      getFilename: () => `${ce(b) || "index"}.${u}.yml`,
+      exportAssets: e
+    });
+  for (const u of p)
+    await te(u, m, {
+      // getFilename: () => `${sanitizeSlug(route.path)}.yml`,
+      getFilename: () => `${ce(u.path) || "index"}.yml`,
+      exportAssets: e
+    });
+  for (const u of l) {
+    const b = t.components[u]?.data;
+    b && await te(b, g, {
+      getFilename: (T) => `${T.name || "unnamed"}.${T.id}.yml`,
+      exportAssets: e
+    });
+  }
+  const w = P(y, ".blocklet/pages/pages.config.yml");
+  F(j(w), { recursive: !0 });
+  const C = {
+    pages: R(
+      a.map((u) => {
+        const b = t.pages[u];
+        return b && { id: u, slug: b.slug };
+      })
+    ),
+    routes: R(
+      d.map((u) => {
+        const b = t.routes[u];
+        return b && { id: u, path: b.path };
+      })
+    ),
+    components: R(
+      l.map((u) => {
+        const b = t.components[u]?.data;
+        return b && {
+          id: u,
+          name: b.name
+        };
+      })
+    ),
+    ...r ? {
+      resources: {
+        components: R(
+          Object.keys(t.resources?.components || {}).filter((u) => l.includes(u)).map((u) => ({
+            id: u,
+            name: t.resources?.components?.[u]?.component?.name
+          }))
+        )
+      }
+    } : {},
+    supportedLocales: t.supportedLocales,
+    config: t.config
+  };
+  oe(w, K.stringify(C));
+  const O = P(y, "config.source.json");
+  if (n && oe(O, JSON.stringify(n)), r) {
+    const u = P(y, "resources"), b = P(u, "components");
+    F(b, { recursive: !0 });
+    for (const W of Object.keys(t?.resources?.components ?? {}).filter(
+      ($) => l.includes($)
+    )) {
+      const $ = t.resources?.components?.[W]?.component;
+      $ && await te($, b, {
+        getFilename: (Y) => `${Y.name || "unnamed"}.${Y.id}.yml`,
+        exportAssets: e
+      });
+    }
+    const T = P(y, "chunks");
+    F(T, { recursive: !0 });
+    const B = Yo();
+    for (const W of Object.keys(t?.resources?.components ?? {}).filter(
+      ($) => l.includes($)
+    )) {
+      const $ = t.resources?.components?.[W]?.component;
+      if ($ && $.renderer?.type === "react-component") {
+        const Y = $.renderer?.chunks ?? [];
+        if (Y?.length > 0)
+          for (const me of Y) {
+            const Te = P(T, me), he = B?.[me];
+            try {
+              he && L(he) && !L(Te) && At(he, Te);
+            } catch (ut) {
+              f.error(`copy chunk ${me} error`, ut.message);
+            }
+          }
+      }
+    }
+  }
+  return y;
+}
+async function Wo(t, { importAssets: e, includeResources: o } = {}) {
+  if (!L(t))
+    return null;
+  let s, n = !1;
+  try {
+    G(t).isDirectory() ? s = t : /\.(tgz|gz|tar)$/.test(t) && (n = !0, s = ot(), await Kt({ file: t, C: s }));
+    const r = se("**/.blocklet/pages/pages.config.yml", { cwd: s, absolute: !0 }).at(0), c = r && P(j(r), "../../pages"), a = r && P(j(r), "../../components"), l = r && P(j(r), "../../routes");
+    if (!r)
+      return null;
+    const d = K.parse(J(r).toString()), I = (g, m, w) => {
+      let C = P(g, `${m}${w ? `.${w}` : ""}.yml`);
+      return (!L(C) || !G(C).isFile()) && (C = P(g, m, `index${w ? `.${w}` : ""}.yml`), !L(C) || !G(C)) ? null : K.parse(J(C).toString());
+    }, h = (g, m) => {
+      try {
+        const w = se(`*.${m}.yml`, { cwd: g, absolute: !0 })[0];
+        return w ? K.parse(J(w).toString()) : null;
+      } catch (w) {
+        f.error("parse component error", w);
+      }
+      return null;
+    }, S = (g, m) => {
+      let w = P(g, `${m}.yml`);
+      return (!L(w) || !G(w).isFile()) && (w = P(g, m, "index.yml"), !L(w) || !G(w)) ? null : K.parse(J(w).toString());
+    }, p = R(
+      d.pages.map(({ slug: g }) => {
+        const m = R(
+          d.supportedLocales.map(({ locale: O }) => {
+            const u = c ? I(c, ce(g), O) : void 0;
+            if (u)
+              return { locale: O, page: u };
+            const b = c ? I(c, g, O) : void 0;
+            return b && { locale: O, page: b };
+          })
+        ), w = m[0]?.page;
+        if (!w)
+          return null;
+        const C = w.sections.map(_t);
+        return {
+          id: w.id || xe(),
+          createdAt: w.createdAt,
+          updatedAt: w.updatedAt,
+          publishedAt: w.publishedAt,
+          isPublic: w.isPublic ?? !0,
+          templateConfig: w.templateConfig,
+          slug: g,
+          sections: Object.fromEntries(C.map((O) => [O.id, O])),
+          sectionIds: C.map((O) => O.id),
+          locales: Object.fromEntries(m.map(({ locale: O, page: u }) => [O, u.meta])),
+          dataSource: w.dataSource ? Object.fromEntries(
+            // 获取 dataSource 中所有 section ID
+            [...new Set(m.flatMap(({ page: O }) => Object.keys(O.dataSource ?? {})))].map((O) => [
+              O,
+              Object.fromEntries(
+                m.map(({ locale: u, page: b }) => {
+                  const T = b.dataSource?.[O];
+                  return [u, T || {}];
+                })
+              )
+            ])
+          ) : Object.fromEntries(
+            // 获取所有 section ID
+            [...new Set(m.flatMap(({ page: O }) => O.sections.map((u) => u.id)))].map((O) => [
+              O,
+              Object.fromEntries(
+                m.map(({ locale: u, page: b }) => {
+                  const T = b.dataSource?.[O];
+                  if (T)
+                    return [u, T];
+                  const B = b.sections.find((W) => W.id === O);
+                  return [u, B?.properties || {}];
+                })
+              )
+            ])
+          )
+        };
+      })
+    ), i = R(
+      d?.routes?.map(({ path: g }) => {
+        const m = l ? S(l, ce(g)) : void 0;
+        return {
+          ...m,
+          id: m?.id || xe(),
+          createdAt: m?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: m?.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          publishedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+          path: m?.path ?? `/${m?.id}`,
+          params: m?.params,
+          handler: m?.handler ?? "Pages Kit",
+          isPublic: m?.isPublic ?? !0,
+          enabledGenerate: m?.enabledGenerate ?? !1,
+          displayTemplateId: m?.displayTemplateId ?? void 0,
+          dataSource: m?.dataSource ?? {}
+        };
+      }) ?? []
+    ), y = a ? R(d.components?.map(({ id: g }) => h(a, g)) ?? []) : [];
+    if (e) {
+      const g = (...m) => {
+        f.info(`[${n ? x(t) : x(P(t, "../../../../"))}] importAssets:`, ...m);
+      };
+      try {
+        g("wait image-bin api ready"), await zt({
+          resources: [`${xt(Zt)}/api/sdk/uploads`],
+          validateStatus: (C) => C >= 200 && C <= 500
+        }), g("image-bin api is ready");
+        const m = {}, w = {};
+        g("start to upload assets"), await Promise.allSettled([
+          Ve(y, m, {
+            getFilePath: (C) => a && P(a, C),
+            onFinish: (C) => {
+              g(`upload ${C.length} component assets`);
+            }
+          }),
+          Ve(p, w, {
+            getFilePath: (C, O) => {
+              const u = Ce(p, O.slice(0, 1));
+              return c && P(c, j(u.slug), C);
+            },
+            onFinish: (C) => {
+              g(`upload ${C.length} page assets`);
+            }
+          })
+        ]), g("upload assets done"), be.clear(), global.gc && global.gc();
+      } catch (m) {
+        g("Error during asset import:", m);
+      }
+    }
+    const A = {};
+    if (o) {
+      const g = r && P(j(r), "../../resources/components"), m = R(
+        d.resources?.components?.map(({ id: w }) => h(g, w)) ?? []
+      );
+      m.length > 0 && (A.components = Object.fromEntries(
+        m.map((w, C) => [w.id, { index: C, component: w }])
+      ));
+    }
+    return {
+      supportedLocales: d.supportedLocales,
+      pageIds: p.map((g) => g.id),
+      components: Object.fromEntries(y.map((g, m) => [g.id, { index: m, data: g }])),
+      pages: Object.fromEntries(p.map((g) => [g.id, g])),
+      config: d.config || {},
+      resources: A,
+      routeIds: i.map((g) => g.id),
+      routes: Object.fromEntries(i.map((g) => [g.id, g])),
+      dataSourceIds: [],
+      dataSources: {}
+    };
+  } finally {
+    n && s && Je(s, { force: !0, recursive: !0 });
+  }
+}
+async function Ge(t, e, {
+  routes: o,
+  mergeMode: s = "byUpdateTime",
+  deleteRoutes: n = !1,
+  publishMode: r = void 0
+} = {}) {
+  try {
+    r && Po(r);
+  } catch (S) {
+    f.error("clear preload page cache error", { error: S });
+  }
+  const { pages: c, pageIds: a, routeIds: l, routes: d, supportedLocales: I } = t;
+  if (r === "production") {
+    let S = o ?? [], p = null;
+    for (const i of l ?? []) {
+      const y = d?.[i];
+      if (y?.params && y?.params.length > 0 && y?.paramsOptions && y?.paramsOptions.length > 0) {
+        const A = Ae({
+          basePath: y.path,
+          params: y.params,
+          routeId: y.id,
+          paramsOptions: y.paramsOptions,
+          currentIndex: 0,
+          currentParams: [],
+          currentOptionIds: [],
+          result: []
+        }), g = Object.fromEntries(A.map((m) => [`${i}-${m.paramOptionIds.join("-")}`, m]));
+        p = { ...p || {}, ...g }, o || (S = [...S, ...A.map((m) => `${i}-${m.paramOptionIds.join("-")}`)]);
+      } else o || S.push(i);
+    }
+    f.info("routeIds to be published: ", S);
+    for (const i of S) {
+      let y = i;
+      if (y.includes("-")) {
+        const [m] = y.split("-");
+        y = m;
+      }
+      const A = d?.[y];
+      if (!A) {
+        const m = e.pageIds.indexOf(y);
+        m !== -1 && n && (e.pageIds.splice(m, 1), delete e.pages[y]);
+        for (const w of e.pageIds)
+          w.includes(`${y}-`) && (e.pageIds.splice(e.pageIds.indexOf(w), 1), delete e.pages[w]);
+        f.info("delete main route page", y);
+        continue;
+      }
+      if (i.includes("-") && !p?.[i]) {
+        const m = e.pageIds.indexOf(i);
+        m !== -1 && n && (e.pageIds.splice(m, 1), delete e.pages[i]), f.info("delete page", i);
+        continue;
+      }
+      if (!A.displayTemplateId) {
+        f.info("no display template", i);
+        continue;
+      }
+      const g = c[A.displayTemplateId];
+      if (!g) {
+        f.info("no template page", i);
+        continue;
+      }
+      if (e.pageIds.includes(i)) {
+        if (f.info("has need update page", i), s === "replace")
+          e.pages[i] = Se({
+            page: g,
+            route: A,
+            state: t,
+            routeId: i,
+            routePathInfo: p?.[i]
+          }), f.info("replace page", i);
+        else if (s === "byUpdateTime") {
+          const m = e.pages[A.id];
+          (!m || A.updatedAt && A.updatedAt > m.updatedAt) && (e.pages[i] = Se({
+            page: g,
+            route: A,
+            state: t,
+            routeId: i,
+            routePathInfo: p?.[i]
+          }), f.info("replace page by update time", i));
+        }
+      } else
+        e.pageIds.push(i), e.pages[i] = Se({
+          page: g,
+          route: A,
+          state: t,
+          routeId: i,
+          routePathInfo: p?.[i]
+        }), f.info("add page", i);
+    }
+    if (n && !o)
+      for (const i of e.pageIds)
+        S?.includes(i) || (delete e.pages[i], f.info("delete page", i)), e.pageIds = [...e.pageIds].filter((y) => S?.includes(y));
+  } else {
+    for (const S of a) {
+      const p = c[S];
+      if (p)
+        if (e.pageIds.includes(p.id)) {
+          if (s === "replace")
+            e.pages[p.id] = p;
+          else if (s === "byUpdateTime") {
+            const i = e.pages[p.id];
+            (!i || p.updatedAt && p.updatedAt > i.updatedAt) && (e.pages[p.id] = p);
+          }
+        } else
+          e.pageIds.push(p.id), e.pages[p.id] = p;
+    }
+    for (const S of l) {
+      const p = d[S];
+      if (p)
+        if (e.routeIds.includes(p.id)) {
+          if (s === "replace")
+            e.routes[p.id] = p;
+          else if (s === "byUpdateTime") {
+            const i = e.routes[p.id];
+            (!i || p.updatedAt && p.updatedAt > i.updatedAt) && (e.routes[p.id] = p);
+          }
+        } else
+          e.routeIds.push(p.id), e.routes[p.id] = p;
+    }
+  }
+  if (e.supportedLocales.splice(0, e.supportedLocales.length), e.supportedLocales.push(...Ft(I)), n)
+    for (const S of Object.keys(e.components))
+      delete e.components[S];
+  let h = JSON.parse(JSON.stringify(t.components));
+  h = Object.fromEntries(
+    await Promise.all(
+      Object.entries(h).map(async ([S, p]) => {
+        const i = await rt(p?.data);
+        return [
+          S,
+          {
+            ...p,
+            data: i
+          }
+        ];
+      })
+    )
+  ), Object.assign(e.components, h), Object.assign(e.config, JSON.parse(JSON.stringify(t.config))), Pe(t.resources.components) || (e.resources.components = JSON.parse(JSON.stringify(t.resources.components || {})));
+}
+const rt = ue(
+  async (t) => {
+    if (!Pe(t?.properties))
+      return t;
+    if (t?.renderer?.type === "react-component") {
+      const { script: e, PROPERTIES_SCHEMA: o } = t?.renderer || {};
+      if (o || e && e.includes("PROPERTIES_SCHEMA"))
+        try {
+          const s = await ko(
+            e ?? "",
+            "PROPERTIES_SCHEMA",
+            t.id,
+            o
+          );
+          s && s.length > 0 && t && (t.properties = {}, s.forEach((n, r) => {
+            t?.properties && (t.properties[n.id] = {
+              index: r,
+              data: n
+            });
+          }));
+        } catch (s) {
+          f.error("getPropertiesFromCode error", { componentId: t.id, name: t.name }, { error: s });
+        }
+    }
+    return t;
+  },
+  {
+    subdir: "getPropertiesFromCode"
+  }
+);
+let pe, X, de, fe;
+const at = () => Rt({
+  types: [
+    { did: tt, type: Ue },
+    { did: Ro, type: Ue }
+  ]
+}), Yo = () => {
+  const t = at(), e = {};
+  return t.forEach((o) => {
+    const s = se("**/.blocklet/pages/pages.config.yml", { cwd: o.path, absolute: !0 }).at(0), n = s && P(j(s), "../../chunks");
+    if (n && L(n)) {
+      const r = Ct(n);
+      for (const c of r)
+        e[c] = P(n, c);
+    }
+  }), e;
+};
+function it() {
+  return pe = (async () => {
+    const t = at();
+    X = (await Promise.all(
+      t.map(async (o) => {
+        const s = o.path ? await Wo(o.path, { importAssets: !1 }) : void 0;
+        return s ? { blockletId: o.did, state: s, blockletTitle: o.title } : void 0;
+      })
+    )).filter((o) => !!o), de = X.reduce(
+      (o, s) => Object.assign(
+        o,
+        Object.fromEntries(
+          Object.values(s.state.pages).map((n) => n ? [n?.id, { page: n, blockletId: s.blockletId }] : [])
+        )
+      ),
+      {}
+    );
+    const e = X.reduce(
+      (o, s) => Object.assign(
+        o,
+        Object.fromEntries(
+          Object.values(s.state.components).map((n) => [n.data.id, { blockletId: s.blockletId, component: n.data }])
+        )
+      ),
+      {}
+    );
+    fe = Object.fromEntries(
+      await Promise.all(
+        Object.entries(e).map(async ([o, s]) => {
+          const n = await rt(s.component);
+          return [
+            o,
+            {
+              ...s,
+              component: n
+            }
+          ];
+        })
+      )
+    );
+  })(), pe;
+}
+function qo(t) {
+  const e = ze(
+    async () => {
+      await it().catch((o) => {
+        f.error("load resource states error", { error: o });
+      }), await t?.({
+        states: X,
+        pages: de,
+        components: fe
+      });
+    },
+    3e3,
+    // 3s
+    { leading: !1, trailing: !0 }
+  );
+  return e(), E.events.on(E.Events.componentAdded, e), E.events.on(E.Events.componentRemoved, e), E.events.on(E.Events.componentStarted, e), E.events.on(E.Events.componentStopped, e), E.events.on(E.Events.componentUpdated, e), E.events.on(Fe, e), () => {
+    E.events.off(E.Events.componentAdded, e), E.events.off(E.Events.componentRemoved, e), E.events.off(E.Events.componentStarted, e), E.events.off(E.Events.componentStopped, e), E.events.off(E.Events.componentUpdated, e), E.events.off(Fe, e);
+  };
+}
+const ct = Symbol.for("GLOBAL_RESOURCE_STATES_LISTENER_KEY"), pt = globalThis;
+pt[ct]?.();
+pt[ct] = qo(async ({ pages: t, components: e }) => {
+  const o = await v.getProjectIds();
+  f.info(`start update resource states projects(${o.length})`, o), await Promise.race([
+    new Promise((s) => {
+      setTimeout(() => {
+        s({});
+      }, 30 * 1e3);
+    }),
+    Promise.all(
+      o.map(async (s) => {
+        lt({
+          projectId: s,
+          pages: t,
+          components: e
+        });
+      })
+    )
+  ]).catch((s) => {
+    f.error("update resource states failed:", s);
+  });
+});
+v.startPeriodicCheck();
+process.on("beforeExit", () => {
+  v.stopPeriodicCheck();
+});
+process.on("SIGINT", () => {
+  v.stopPeriodicCheck(), process.exit(0);
+});
+process.on("SIGTERM", () => {
+  v.stopPeriodicCheck(), process.exit(0);
+});
+async function lt({
+  projectId: t,
+  pages: e,
+  components: o
+}) {
+  const s = v.sharedInstances[t];
+  if (!s) {
+    f.info(`projectId: ${t} not found in sharedInstances`);
+    return;
+  }
+  if (s.syncedStore.resources.pages = e, (await N.findByPk(t))?.useAllResources)
+    s.syncedStore.resources.components = o;
+  else {
+    const c = (await Oe.findAll({ where: { projectId: t } })).map((l) => l.componentId), a = Object.fromEntries(
+      Object.entries(o || {}).filter(([l]) => c.includes(l))
+    );
+    s.syncedStore.resources.components = a;
+  }
+  f.info(`update [${t}] resource states:`, {
+    pages: Object.keys(s.syncedStore.resources.pages || {}).length,
+    components: Object.keys(s.syncedStore.resources.components || {}).length
+  });
+}
+async function Qo({
+  ensureLoaded: t = !0
+} = {}) {
+  return t && (pe ??= it(), await pe), { states: X, pages: de, components: fe };
+}
+E.events.on(E.Events.envUpdate, () => {
+  v.pageUrlMapCache.clear(), f.info("clear all page url map cache");
+});
+export {
+  tt as C,
+  N as P,
+  Ue as R,
+  v as S,
+  Qo as a,
+  Us as b,
+  _s as g,
+  Ns as i,
+  f as l,
+  Ho as t
+};