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

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

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