@blocklet/pages-kit-inner-components 0.6.7 → 0.6.8

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

@@ -0,0 +1,1586 @@
+import { d as Le, l as f, I as Ye, c as We, m as Qe, b as Xe } from "./components-B8AH-ivu.js";
+import { getYjsValue as V, syncedStore as Ze } from "@syncedstore/core";
+import * as N from "yjs";
+import { setPageDataSource as et } from "@blocklet/pages-kit/utils/data-source";
+import { getRouteMetaDataByOptionIds as tt, generateParamCombinations as Se } from "@blocklet/pages-kit/utils/route";
+import { cloneDeep as st } from "lodash";
+import I from "@blocklet/sdk/lib/config";
+import { mkdtempSync as at, existsSync as U, readFileSync as H, renameSync as Ce, mkdirSync as _, rmSync as $e, writeFileSync as ee, copyFileSync as ot, lstatSync as B, readdirSync as rt, createWriteStream as nt } from "fs";
+import { join as E, basename as j, dirname as L } from "path";
+import { nextId as Oe } from "@blocklet/pages-kit/utils/common";
+import { unzipSection as it } from "@blocklet/pages-kit/utils/page-model";
+import { getComponentDependencies as ct } from "@blocklet/pages-kit/utils/property";
+import { getComponentWebEndpoint as pt, getResources as lt, call as dt } from "@blocklet/sdk/lib/component";
+import { reactive as ut } from "@reactivedata/reactive";
+import { globSync as te } from "glob";
+import * as de from "lib0/decoding";
+import * as D from "lib0/encoding";
+import ft from "lodash/cloneDeep";
+import Ue from "lodash/debounce";
+import Ie from "lodash/get";
+import Ee from "lodash/isEmpty";
+import ve from "lodash/set";
+import mt from "lodash/union";
+import { LRUCache as be } from "lru-cache";
+import ht from "p-limit";
+import { DataTypes as k, Sequelize as gt, Model as Me, Op as Ne } from "sequelize";
+import { pipeline as yt } from "stream/promises";
+import { x as St } from "tar";
+import { joinURL as Y } from "ufo";
+import It from "wait-on";
+import { Awareness as Et, encodeAwarenessUpdate as ke, removeAwarenessStates as bt, applyAwarenessUpdate as wt } from "y-protocols/awareness";
+import { writeUpdate as At, writeSyncStep1 as Pt, readSyncMessage as Ct } from "y-protocols/sync";
+import * as G from "yaml";
+import "sqlite3";
+import "@blocklet/pages-kit/types/state";
+const Ot = k.sqlite.DATE.parse;
+k.sqlite.DATE.parse = (t, e) => typeof t == "number" ? new Date(t) : Ot(t, e);
+const F = new gt({
+  dialect: "sqlite",
+  storage: Le,
+  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,
+});
+F.query("pragma journal_mode = WAL;");
+F.query("pragma synchronous = normal;");
+F.query("pragma journal_size_limit = 33554432;");
+F.query("pragma cache_size = -2000;");
+F.query("pragma mmap_size = 33554432;");
+process.on("SIGINT", async () => {
+  await F.close(), process.exit(0);
+});
+process.on("SIGTERM", async () => {
+  await F.close(), process.exit(0);
+});
+async function vt(t, e) {
+  try {
+    if (t.getDialect() !== "sqlite")
+      return;
+    const [s] = await t.query("SELECT 1");
+    if (!s || s.length === 0)
+      return;
+    await t.query("PRAGMA shrink_memory;");
+  } catch (s) {
+    if (s.name === "SequelizeConnectionError" || s?.message && /closed!/.test(s.message))
+      return;
+    console.error("Failed to cleanup SQLite memory", e, s);
+  }
+}
+let me = null;
+me && clearInterval(me);
+me = setInterval(
+  async () => {
+    f.info("Start cleanupSqliteMemory"), await vt(F, Le), f.info("End cleanupSqliteMemory");
+  },
+  60 * 1e3 * 10
+  // 10 minutes
+);
+class we extends Me {
+  // Foreign key to Component
+}
+we.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: F, tableName: "ProjectComponents", timestamps: !1 }
+);
+class M extends Me {
+  static async getProjectByIdOrSlug(e) {
+    return M.findOne({
+      where: {
+        [Ne.or]: [{ id: e }, { slug: e }]
+      }
+    });
+  }
+}
+M.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");
+        if (typeof t == "object")
+          return t ?? {};
+        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");
+        if (typeof t == "object")
+          return t ?? {};
+        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: F, paranoid: !0 }
+);
+M.hasMany(we, {
+  foreignKey: "projectId",
+  as: "components"
+});
+const kt = "z8iZiDFg3vkkrPwsiba1TLXy3H9XHzFERsP8o", Te = "page", he = "trigger-reload-project-resource", Fe = kt, Tt = "z2qa7BQdkEb3TwYyEYC1psK6uvmGnHSUHt5RM";
+function se(t) {
+  t.observeDeep((e) => {
+    e.some((s) => s.changes.keys.has("updatedAt") || s.changes.keys.has("publishedAt")) || t.set("updatedAt", (/* @__PURE__ */ new Date()).toISOString());
+  });
+}
+function _e() {
+  return at(E(I.env.dataDir, "tmp-"));
+}
+function ae(t, e, s = []) {
+  return Array.isArray(t) ? t.flatMap((a, o) => ae(a, e, [...s, o])) : typeof t == "object" ? t === null ? [] : Object.entries(t).flatMap(([a, o]) => ae(o, e, [...s, a])) : e(t) ? [s] : [];
+}
+function R(t) {
+  return t.filter((e) => e != null);
+}
+function Dt(t) {
+  t.pages && Object.keys(t.pages).forEach((s) => {
+    const a = V(t.pages[s]);
+    a && a instanceof N.Map && se(a);
+  });
+  const e = V(t.pages);
+  e && e instanceof N.Map && e.observe((s) => {
+    s.changes.keys.forEach((a, o) => {
+      if (a.action === "add") {
+        const r = V(t.pages[o]);
+        r && r instanceof N.Map && se(r);
+      }
+    });
+  });
+}
+function Rt(t) {
+  t.routes && Object.keys(t.routes).forEach((s) => {
+    const a = V(t.routes?.[s]);
+    a && a instanceof N.Map && se(a);
+  });
+  const e = V(t.routes);
+  e && e instanceof N.Map && e.observe((s) => {
+    s.changes.keys.forEach((a, o) => {
+      if (a.action === "add") {
+        const r = V(t.routes?.[o]);
+        r && r instanceof N.Map && se(r);
+      }
+    });
+  });
+}
+function jt(t, e) {
+  for (const s of e || Object.keys(t.routes || {})) {
+    let a = s, o = [];
+    if (s.includes("-")) {
+      const [r, ...i] = s.split("-");
+      a = r, o = i || [];
+    }
+    if (t.routes?.[a] !== void 0) {
+      t.routes[a].publishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const r = t.routes[a];
+      if (!r || !r.params || r.params.length === 0)
+        continue;
+      if (s.includes("-") && o.length > 0) {
+        const i = tt(o, r);
+        i && (i.publishedAt = (/* @__PURE__ */ new Date()).toISOString());
+      }
+      if (!e) {
+        const i = Se({
+          basePath: r.path,
+          params: r.params,
+          routeId: r.id,
+          paramsOptions: r.paramsOptions,
+          currentIndex: 0,
+          currentParams: [],
+          currentOptionIds: [],
+          result: []
+        });
+        for (const c of i)
+          c.routeMetaData ??= {}, c.routeMetaData.publishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    }
+  }
+}
+function ue({
+  page: t,
+  route: e,
+  state: s,
+  routeId: a,
+  routePathInfo: o
+}) {
+  f.info(
+    `Executing datasource data assembly, routeId: ${a}, routePathInfo: ${JSON.stringify(o)}`
+  );
+  const r = {
+    ...st(t),
+    id: a,
+    slug: o?.path ?? e.path,
+    createdAt: e.createdAt,
+    updatedAt: o?.routeMetaData?.updatedAt ?? e.updatedAt,
+    publishedAt: o?.routeMetaData?.publishedAt ?? e.publishedAt,
+    isPublic: (o?.routeMetaData?.isPublic ?? e.isPublic) && e.isPublic
+  };
+  for (const i of s.supportedLocales) {
+    if (e.dataSource) {
+      let c = e.id;
+      o && (c = o.paramOptionIds.join("-"));
+      const l = e.dataSource.pathDataMappings?.[c]?.dataCache?.[i.locale] ?? e.dataSource.pathDataMappings?.[c]?.dataCache?.[s.config.defaultLocale || "en"];
+      if (!l)
+        continue;
+      et(r, s, i.locale, l);
+    }
+    o && o.routeMetaData && (o.routeMetaData.publishedAt = (/* @__PURE__ */ new Date()).toISOString());
+  }
+  return r;
+}
+const Lt = 30 * 60 * 1e3, z = new be({
+  max: 100,
+  ttl: Lt
+});
+function $t(t, e = []) {
+  let s = 0;
+  const a = Array.from(z.keys()), o = [];
+  for (const r of t) {
+    o.push(`page-html:prod:${r}:lang-path=none`);
+    for (const i of e)
+      o.push(`page-html:prod:/${i}${r}:lang-path=${i}`);
+  }
+  for (const r of a) {
+    const i = r.split(":lang-path=")[0] || "";
+    for (const c of o) {
+      const m = (c.split(":lang-path=")[0] || "").replace(/\/:[^/]+/g, "");
+      if (i.startsWith(m)) {
+        z.delete(r), s++, f.info(`[Cache CLEAR] key: ${r}`);
+        break;
+      }
+    }
+  }
+  return f.info(`[Cache CLEAR] cleared ${s} entries for patterns:`, o), s;
+}
+function Ut({
+  projectId: t,
+  projectSlug: e,
+  supportedLocales: s = []
+}) {
+  let a = 0;
+  const o = Array.from(z.keys()), r = [];
+  r.push(`page-html:prod:/${t}`), e && e !== t && r.push(`page-html:prod:/${e}`);
+  for (const i of s)
+    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 o)
+    for (const c of r)
+      if (i.startsWith(c)) {
+        z.delete(i), a++, f.info(`[Cache CLEAR PROJECT] key: ${i}`);
+        break;
+      }
+  return f.info(
+    `[Cache CLEAR PROJECT] cleared ${a} entries for project ${t}${e ? ` (slug: ${e})` : ""}`
+  ), a;
+}
+function Mt() {
+  const t = z.size;
+  return z.clear(), f.info(`[Cache CLEAR ALL] cleared ${t} entries`), t;
+}
+I.events.on(I.Events.envUpdate, Mt);
+const { uploadToMediaKit: Nt } = require("@blocklet/uploader-server"), Ae = /^\w+(\w|-|\.)+\w+\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm)$/, W = /mediakit:\/\/([a-f0-9]{32}\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm))/i, De = /mediakit:\/\/([a-f0-9]{32}\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm))/gi, Ft = 1e4, _t = 3e4, X = 0, fe = 1, xt = 0, Bt = 1, ge = I, q = E(process.env.BLOCKLET_DATA_DIR, "site-state"), Os = ["production", "draft"], vs = ["production"];
+function oe(t) {
+  return t?.replace(/\//g, "|") || "";
+}
+function Gt() {
+  const t = ge.env.languages?.map((s) => ({ locale: s.code, name: s.name })) || [], e = t[0]?.locale || "en";
+  return {
+    pageIds: [],
+    pages: {},
+    routeIds: [],
+    routes: {},
+    dataSourceIds: [],
+    dataSources: {},
+    components: {},
+    supportedLocales: t,
+    config: { defaultLocale: e },
+    resources: {}
+  };
+}
+class C extends N.Doc {
+  constructor(e) {
+    super(), this.options = e, U(this.draftYjsFilePath) && N.applyUpdate(this, H(this.draftYjsFilePath)), this.syncedStore = ut(
+      Ze(
+        {
+          pages: {},
+          pageIds: [],
+          components: {},
+          supportedLocales: [],
+          config: {},
+          resources: {},
+          routeIds: [],
+          routes: {},
+          dataSourceIds: [],
+          dataSources: {}
+        },
+        this
+      )
+    ), this.initObserver(), this.on("update", this.updateHandler), this.awareness = new Et(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 be({
+    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 s = E(q, e), a = E(q, `@del-${e}`);
+      Ce(s, a);
+    } catch (s) {
+      f.error("Failed to safe delete project state dir:", s);
+    }
+  }
+  static async getProjectIds() {
+    return (await M.findAll({ attributes: ["id"], raw: !0 }))?.map((e) => e.id);
+  }
+  /** @deprecated 不再使用这个 getter 了，仅作为兼容性处理，请使用 getProjectIds 代替 */
+  static get projectIds() {
+    return te("*/", {
+      cwd: q,
+      ignore: ["@del-*", "@tmp-*", ".*", "staging", "production", "@backup-*", "undefined"]
+      // Ignore temp directories and hidden files
+    });
+  }
+  /** @deprecated 不再使用这个 getter 了，仅作为兼容性处理 */
+  static get allShared() {
+    return this.projectIds.map((e) => C.shared(e));
+  }
+  static shared(e) {
+    if (!e)
+      throw new Error("Should provide project context");
+    let s = C.sharedInstances[e];
+    return s || (s = new C({
+      path: E(q, e)
+    }), C.sharedInstances[e] = s, qe({
+      projectId: e,
+      pages: ne,
+      components: ie
+    }), s);
+  }
+  // 轻量级 production 状态获取，不加载 draft 数据
+  static async getProductionState(e) {
+    const s = await M.findByPk(e, {
+      attributes: ["productionState"]
+    });
+    if (Ee(s?.productionState)) {
+      const a = E(q, e, "production"), o = await Be(a, { includeResources: !0 }) ?? Gt();
+      if (!o?.config?.defaultLocale) {
+        o.config ??= {};
+        const r = ge.env.languages?.map((i) => ({ locale: i.code, name: i.name })) || [];
+        o.config.defaultLocale = r[0]?.locale;
+      }
+      return o;
+    }
+    return s?.productionState;
+  }
+  destroy() {
+    this.cancelRelease(), this.save({ flush: !0 }), this.conns.forEach((s, a) => this.closeConn(a)), this.awareness.destroy();
+    const e = j(this.options.path);
+    delete C.sharedInstances[e], super.destroy();
+  }
+  initObserver() {
+    Dt(this.syncedStore), Rt(this.syncedStore);
+  }
+  get draftYjsFilePath() {
+    return E(this.options.path, "draft.yjs");
+  }
+  static async getStateByProjectId(e, s) {
+    if (s === "draft") {
+      const a = C.shared(e);
+      return JSON.parse(JSON.stringify(a.syncedStore));
+    }
+    return C.getProductionState(e);
+  }
+  async getState(e) {
+    if (e === "draft")
+      return JSON.parse(JSON.stringify(this.syncedStore));
+    const s = j(this.options.path);
+    return C.getProductionState(s);
+  }
+  async setState(e, s) {
+    const a = await Kt(s, { exportAssets: !1, includeResources: !0 }), o = this.getPublishDir(e);
+    if (_(L(o), { recursive: !0 }), $e(o, { force: !0, recursive: !0 }), Ce(a, o), e === "production") {
+      const r = j(this.options.path);
+      C.pageUrlMapCache.delete(r), await M.update({ productionState: { ...s } }, { where: { id: r } });
+    }
+  }
+  getPublishDir(e) {
+    return E(this.options.path, e);
+  }
+  syncedStore;
+  conns = /* @__PURE__ */ new Map();
+  awareness;
+  // 延迟释放定时器
+  releaseTimer;
+  awarenessChangeHandler = ({ added: e, updated: s, removed: a }, o) => {
+    const r = e.concat(s, a);
+    if (o !== null) {
+      const l = this.conns.get(o);
+      l && (e.forEach((m) => {
+        l.add(m);
+      }), a.forEach((m) => {
+        l.delete(m);
+      }));
+    }
+    const i = D.createEncoder();
+    D.writeVarUint(i, fe), D.writeVarUint8Array(i, ke(this.awareness, r));
+    const c = D.toUint8Array(i);
+    this.conns.forEach((l, m) => this.send(m, c));
+  };
+  updateHandler = (e) => {
+    const s = D.createEncoder();
+    D.writeVarUint(s, X), At(s, e);
+    const a = D.toUint8Array(s);
+    this.conns.forEach((o, r) => this.send(r, a));
+  };
+  ensureDataStructure = () => {
+    const { supportedLocales: e, pages: s, pageIds: a, config: o, routes: r, routeIds: i } = this.syncedStore;
+    {
+      const c = new Set(Object.keys(s));
+      let l = 0;
+      for (; l < a.length; ) {
+        const m = a[l];
+        c.has(m) ? (c.delete(m), l++) : a.splice(l, 1);
+      }
+    }
+    {
+      const c = new Set(Object.keys(r));
+      let l = 0;
+      for (; l < i.length; ) {
+        const m = i[l];
+        c.has(m) ? (c.delete(m), l++) : i.splice(l, 1);
+      }
+    }
+    e.splice(0, e.length), e.push(...ge.env.languages.map((c) => ({ locale: c.code, name: c.name }))), o.defaultLocale = e[0]?.locale;
+    {
+      let c = 0;
+      const l = /* @__PURE__ */ new Set();
+      for (; c < e.length; ) {
+        const { locale: m } = e[c];
+        l.has(m) ? e.splice(c, 1) : (c++, l.add(m));
+      }
+    }
+  };
+  send = (e, s) => {
+    e.readyState !== xt && e.readyState !== Bt && this.closeConn(e);
+    try {
+      e.send(s, (a) => {
+        a && this.closeConn(e);
+      });
+    } catch {
+      this.closeConn(e);
+    }
+  };
+  closeConn = (e) => {
+    if (e.removeAllListeners(), this.conns.has(e)) {
+      const s = this.conns.get(e);
+      this.conns.delete(e), s && bt(this.awareness, Array.from(s), null);
+    }
+    e.close(), this.checkAndScheduleRelease();
+  };
+  // 检查并调度延迟释放
+  checkAndScheduleRelease() {
+    this.conns.size === 0 && this.scheduleRelease();
+  }
+  // 调度延迟释放
+  scheduleRelease() {
+    this.cancelRelease();
+    const e = j(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());
+    }, C.RELEASE_DELAY), f.info(`[SiteState] scheduled release for project ${e} in ${C.RELEASE_DELAY / 1e3}s`);
+  }
+  // 取消延迟释放
+  cancelRelease() {
+    if (this.releaseTimer) {
+      clearTimeout(this.releaseTimer), this.releaseTimer = void 0;
+      const e = j(this.options.path);
+      f.info(`[SiteState] cancelled scheduled release for project ${e}`);
+    }
+  }
+  autoSave = Ue(() => {
+    _(L(this.draftYjsFilePath), { recursive: !0 }), ee(this.draftYjsFilePath, N.encodeStateAsUpdate(this));
+  }, Ft);
+  save = ({ flush: e = !1 } = {}) => {
+    this.autoSave(), e && this.autoSave.flush();
+  };
+  publish = async ({ mode: e, routes: s }) => {
+    const a = await this.getState("draft"), o = await this.getState("production");
+    await je(a, o, { routes: s, mergeMode: "replace", deleteRoutes: !0, publishMode: e }), o.config.publishedAt = (/* @__PURE__ */ new Date()).getTime(), jt(this.syncedStore, s), await this.setState(e, o), await this.clearPageCacheForRoutes(s, o);
+  };
+  mergeState = async (e, s) => {
+    const a = JSON.parse(JSON.stringify(s));
+    e.config.fontFamily ??= {};
+    const o = a.config?.fontFamily, r = e.config?.fontFamily;
+    e.config.fontFamily.title = o?.title || r?.title, e.config.fontFamily.description = o?.description || r?.description, await new Promise((i, c) => {
+      this.transact(async () => {
+        try {
+          const l = await je(e, s);
+          i(l);
+        } catch (l) {
+          c(l);
+        }
+      });
+    });
+  };
+  clearPageCacheForRoutes = async (e, s) => {
+    const a = j(this.options.path), r = (await M.findByPk(a))?.slug || a;
+    if (f.info(`[SiteState] clearing page cache for project ${a}, routes:`, e || []), !e || e.length === 0) {
+      Ut({
+        projectId: a,
+        projectSlug: r,
+        supportedLocales: s.supportedLocales.map((m) => m.locale)
+      });
+      return;
+    }
+    const i = s.supportedLocales.map((m) => m.locale), c = [], l = e.filter((m) => s.pages[m]);
+    for (const m of l) {
+      const O = s.pages[m].slug;
+      r && r !== a && (r === "/" ? c.push(O) : c.push(`/${r}${O}`)), c.push(`/${a}${O}`);
+    }
+    if (f.info(`[SiteState] clearing page cache for project ${a}, pathPatterns:`, c), c.length > 0) {
+      const m = $t(c, i);
+      f.info(`[SiteState] cleared ${m} page cache entries for project ${a}, 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", (o) => this.messageListener(e, new Uint8Array(o)));
+    let s = !0;
+    const a = setInterval(() => {
+      if (!s)
+        this.conns.has(e) && this.closeConn(e), clearInterval(a);
+      else if (this.conns.has(e)) {
+        s = !1;
+        try {
+          e.ping();
+        } catch {
+          this.closeConn(e), clearInterval(a);
+        }
+      }
+    }, _t);
+    e.on("close", () => {
+      this.closeConn(e), clearInterval(a);
+    }), e.on("pong", () => {
+      s = !0;
+    });
+    {
+      const o = D.createEncoder();
+      D.writeVarUint(o, X), Pt(o, this), this.send(e, D.toUint8Array(o));
+      const r = this.awareness.getStates();
+      if (r.size > 0) {
+        const i = D.createEncoder();
+        D.writeVarUint(i, fe), D.writeVarUint8Array(i, ke(this.awareness, Array.from(r.keys()))), this.send(e, D.toUint8Array(i));
+      }
+    }
+  };
+  messageListener = (e, s) => {
+    try {
+      const a = D.createEncoder(), o = de.createDecoder(s), r = de.readVarUint(o);
+      switch (r) {
+        case X:
+          D.writeVarUint(a, X), Ct(o, a, this, null), D.length(a) > 1 && (this.ensureDataStructure(), this.send(e, D.toUint8Array(a)));
+          break;
+        case fe: {
+          wt(this.awareness, de.readVarUint8Array(o), e);
+          break;
+        }
+        default:
+          f.warn(`Unsupported messageType ${r}`);
+      }
+    } catch (a) {
+      f.error(a);
+    }
+    this.save();
+  };
+  // 这个方法还是需要动态的，因为可能会动态修改 projectSlug、语言之类的
+  static async pageUrlMap(e, s) {
+    let a = [];
+    s ? a = [s] : a = await this.getProjectIds();
+    let o = {};
+    if (e === "production" && a?.length) {
+      const r = new Map(a?.map((i) => [i, !0]) || []);
+      for (const i of a) {
+        const c = C.pageUrlMapCache.get(i);
+        c && (o = { ...o, ...c }, r.delete(i));
+      }
+      a = Array.from(r.keys());
+    }
+    if (a?.length) {
+      const r = await M.findAll({
+        where: {
+          id: {
+            [Ne.in]: a
+          }
+        }
+      });
+      await Promise.all(
+        r?.map(async (i) => {
+          const c = i.id, l = i.slug || c, m = {}, T = e === "production" && i?.productionState ? i.productionState : await C.getStateByProjectId(i.id, e), O = mt(
+            I.env.languages?.map((d) => d.code) || [],
+            T.supportedLocales?.map((d) => d.locale) || []
+          ), b = (d, p) => {
+            l && (m[Y("/", l, d)] = {
+              ...p,
+              shouldRedirect: !0,
+              mainPage: !0
+            }), m[Y("/", c, d)] = {
+              ...p,
+              shouldRedirect: !0,
+              mainPage: !0
+            };
+            for (const g of O) {
+              const P = { ...p, locale: g };
+              m[Y("/", g, c, d)] = P, l && (m[Y("/", g, l, d)] = P);
+            }
+          };
+          if (e === "draft")
+            for (const d of T.routeIds || []) {
+              const p = T?.routes?.[d];
+              if (!p) continue;
+              if (p.params && p.params.length > 0) {
+                const h = Se({
+                  basePath: p.path,
+                  params: p.params,
+                  routeId: p.id,
+                  paramsOptions: p.paramsOptions,
+                  currentIndex: 0,
+                  currentParams: [],
+                  currentOptionIds: [],
+                  result: []
+                });
+                for (const u of h) {
+                  const y = u.path, w = {
+                    projectId: c,
+                    projectSlug: l,
+                    pageSlug: y,
+                    pageId: p.displayTemplateId || "",
+                    routeId: d,
+                    // default locale
+                    defaultLocale: O?.[0],
+                    locales: O,
+                    publishedAt: T.config.publishedAt,
+                    isPublic: p.isPublic && u?.routeMetaData?.isPublic
+                  };
+                  b(y, w);
+                }
+              }
+              const g = p.path, P = {
+                projectId: c,
+                projectSlug: l,
+                pageSlug: g,
+                pageId: p.displayTemplateId || "",
+                routeId: d,
+                // default locale
+                defaultLocale: O?.[0],
+                locales: O,
+                publishedAt: T.config.publishedAt,
+                isPublic: p.isPublic
+              };
+              b(g, P);
+            }
+          for (const d of T.pageIds) {
+            const p = T.pages[d];
+            if (!p || e === "production" && !p.isPublic)
+              continue;
+            const g = p.slug, P = i.slug || c, h = {
+              projectId: c,
+              projectSlug: P,
+              pageSlug: g,
+              pageId: d,
+              // default locale
+              defaultLocale: O?.[0],
+              locales: O,
+              publishedAt: T.config.publishedAt,
+              isPublic: p.isPublic,
+              templateConfig: p.templateConfig
+            };
+            b(g, h);
+          }
+          e === "production" && C.pageUrlMapCache.set(c, m), o = { ...o, ...m };
+        })
+      );
+    }
+    return o;
+  }
+  getDocumentSize() {
+    return N.encodeStateAsUpdate(this).byteLength;
+  }
+  static getInstancesSizeInfo() {
+    const e = [];
+    for (const [s, a] of Object.entries(C.sharedInstances)) {
+      const o = a.getDocumentSize();
+      e.push({
+        projectId: s,
+        sizeInBytes: o,
+        sizeInMB: `${(o / (1024 * 1024)).toFixed(2)} MB`,
+        activeConnections: a.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(C.sharedInstances).length, s = [], a = [];
+    for (const [o, r] of Object.entries(C.sharedInstances))
+      r.conns.size === 0 ? s.push({ projectId: o, instance: r }) : a.push({ projectId: o, connections: r.conns.size });
+    if (f.info(
+      `[SiteState] periodic check summary: total instances: ${e}, with connections: ${a.length}, without connections: ${s.length}`
+    ), s.length > 0) {
+      f.info(
+        `[SiteState] releasing ${s.length} instances without connections:`,
+        s.map((r) => r.projectId)
+      );
+      let o = 0;
+      for (const { projectId: r, instance: i } of s)
+        try {
+          f.info(`[SiteState] releasing instance due to periodic check: ${r}`), i.destroy(), o++;
+        } catch (c) {
+          f.error(`[SiteState] failed to release instance ${r} during periodic check:`, c);
+        }
+      f.info(
+        `[SiteState] periodic check completed: ${o}/${s.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 Vt(t, e, s) {
+  if (!t || !U(t) || !B(t).isFile())
+    return null;
+  let a = s[t];
+  return a || (a = (async () => {
+    try {
+      return (await Nt({
+        filePath: t,
+        fileName: e
+      }))?.data?.filename;
+    } catch (o) {
+      return f.error(`Failed to upload asset ${t}:`, o), null;
+    }
+  })(), s[t] = a), a;
+}
+const zt = async (t, e) => {
+  const s = j(t), a = await dt({
+    name: Fe,
+    path: Y("/uploads", s),
+    responseType: "stream",
+    method: "GET"
+  });
+  if (a.status >= 200 && a.status < 400) {
+    const o = nt(e);
+    await yt(a.data, o);
+  } else
+    throw new Error(`download asset failed ${a.status}`);
+}, Jt = async (t, e) => {
+  await Promise.all(
+    t.map(async (s) => {
+      try {
+        await zt(s, E(e, j(s)));
+      } catch (a) {
+        f.error(`Failed to export assets: ${s}, ${a}`);
+      }
+    })
+  );
+};
+function xe(t) {
+  return Ae.test(t) ? [t] : W.test(t) ? (De.lastIndex = 0, Array.from(t.matchAll(De)).map((s) => s[1]).filter((s) => !!s)) : [];
+}
+async function Z(t, e, s) {
+  const { getFilename: a, exportAssets: o } = s, r = E(e, a(t));
+  if (_(L(r), { recursive: !0 }), ee(r, G.stringify(t)), o) {
+    const c = ae(
+      t,
+      (l) => typeof l == "string" && (Ae.test(l) || W.test(l))
+    ).map((l) => {
+      const m = Ie(t, l);
+      return xe(m);
+    }).flat().filter(Boolean);
+    await Jt(c, L(r));
+  }
+}
+const ye = new be({
+  max: 100,
+  ttl: 1 * 60 * 1e3
+  // 1 minute
+});
+async function Re(t, e, s) {
+  const a = ae(
+    t,
+    (c) => typeof c == "string" && (Ae.test(c) || W.test(c))
+  ), o = ht(2), r = a.map(
+    (c) => o(async () => {
+      try {
+        const l = Ie(t, c), m = xe(l);
+        for (const T of m) {
+          const O = j(T), b = s.getFilePath(T, c), d = b ? `${b}:${O}` : O, p = ye.get(d);
+          if (p) {
+            W.test(l) || ve(t, c, p);
+            return;
+          }
+          const g = await Vt(b, O, e);
+          g && (W.test(l) || ve(t, c, g), ye.set(d, g));
+        }
+      } catch (l) {
+        f.error(`Failed to process upload for path ${c.join(".")}:`, l.message || l.reason);
+      }
+    })
+  ), i = await Promise.allSettled(r);
+  s.onFinish?.(i);
+}
+async function Kt(t, {
+  exportAssets: e,
+  pageIds: s = "all",
+  componentIds: a = "all",
+  rawConfig: o,
+  includeResources: r = !1,
+  routeIds: i = "all"
+} = {}) {
+  const c = s === "all" ? t.pageIds : s, l = ct({
+    state: t,
+    pageIds: c,
+    componentIds: a === "all" ? Object.keys(t.components) : a
+  }), m = i === "all" ? t.routeIds : i, T = (n) => ({
+    id: n.id,
+    name: n.name,
+    isTemplateSection: n.isTemplateSection ?? !1,
+    templateDescription: n.templateDescription,
+    llmConfig: n.llmConfig,
+    component: n.component,
+    config: n.config,
+    visibility: n.visibility,
+    sections: n?.sectionIds ? R(
+      n?.sectionIds?.map((S) => {
+        const v = n.sections?.[S];
+        return v && T(v);
+      })
+    ) : void 0
+    // 已经废弃，数据在 page.dataSource 中管理
+    // properties: section.locales?.[locale] ?? {},
+  }), O = (n, S) => ({
+    id: n.id,
+    createdAt: n.createdAt,
+    updatedAt: n.updatedAt,
+    publishedAt: n.publishedAt,
+    isPublic: n.isPublic ?? !0,
+    templateConfig: n.templateConfig,
+    meta: n.locales?.[S] ?? {},
+    sections: R(
+      n.sectionIds.map((v) => {
+        const x = n.sections[v];
+        return x && T(x);
+      })
+    ),
+    // 将 dataSource.sectionId.locale 转换为 dataSource.sectionId
+    dataSource: Object.fromEntries(
+      Object.entries(n.dataSource || {}).map(([v, x]) => [v, x?.[S] ?? {}])
+    )
+  }), b = (n) => ({
+    id: n.id,
+    createdAt: n.createdAt,
+    updatedAt: n.updatedAt,
+    publishedAt: n.publishedAt,
+    path: n.path,
+    handler: n.handler,
+    isPublic: n.isPublic ?? !0,
+    params: n.params ?? [],
+    enabledGenerate: n.enabledGenerate ?? !1,
+    displayTemplateId: n.displayTemplateId,
+    dataSource: n.dataSource
+  }), d = R(
+    m.map((n) => {
+      const S = t.routes[n];
+      return S && b(S);
+    })
+  ), p = R(
+    t.supportedLocales.map((n) => n.locale).flatMap(
+      (n) => c.map((S) => {
+        const v = t.pages[S];
+        return v && {
+          locale: n,
+          slug: v.slug,
+          page: O(v, n)
+        };
+      })
+    )
+  ), g = _e(), P = E(g, "pages");
+  _(P, { recursive: !0 });
+  const h = E(g, "components");
+  _(h, { recursive: !0 });
+  const u = E(g, "routes");
+  _(u, { recursive: !0 });
+  for (const { locale: n, slug: S, page: v } of p)
+    await Z(v, P, {
+      getFilename: () => `${oe(S) || "index"}.${n}.yml`,
+      exportAssets: e
+    });
+  for (const n of d)
+    await Z(n, u, {
+      // getFilename: () => `${sanitizeSlug(route.path)}.yml`,
+      getFilename: () => `${oe(n.path) || "index"}.yml`,
+      exportAssets: e
+    });
+  for (const n of l) {
+    const S = t.components[n]?.data;
+    S && await Z(S, h, {
+      getFilename: (v) => `${v.name || "unnamed"}.${v.id}.yml`,
+      exportAssets: e
+    });
+  }
+  const y = E(g, ".blocklet/pages/pages.config.yml");
+  _(L(y), { recursive: !0 });
+  const w = {
+    pages: R(
+      c.map((n) => {
+        const S = t.pages[n];
+        return S && { id: n, slug: S.slug };
+      })
+    ),
+    routes: R(
+      m.map((n) => {
+        const S = t.routes[n];
+        return S && { id: n, path: S.path };
+      })
+    ),
+    components: R(
+      l.map((n) => {
+        const S = t.components[n]?.data;
+        return S && {
+          id: n,
+          name: S.name
+        };
+      })
+    ),
+    ...r ? {
+      resources: {
+        components: R(
+          Object.keys(t.resources?.components || {}).filter((n) => l.includes(n)).map((n) => ({
+            id: n,
+            name: t.resources?.components?.[n]?.component?.name
+          }))
+        )
+      }
+    } : {},
+    supportedLocales: t.supportedLocales,
+    config: t.config
+  };
+  ee(y, G.stringify(w));
+  const A = E(g, "config.source.json");
+  if (o && ee(A, JSON.stringify(o)), r) {
+    const n = E(g, "resources"), S = E(n, "components");
+    _(S, { recursive: !0 });
+    for (const J of Object.keys(t?.resources?.components ?? {}).filter(
+      ($) => l.includes($)
+    )) {
+      const $ = t.resources?.components?.[J]?.component;
+      $ && await Z($, S, {
+        getFilename: (K) => `${K.name || "unnamed"}.${K.id}.yml`,
+        exportAssets: e
+      });
+    }
+    const v = E(g, "chunks");
+    _(v, { recursive: !0 });
+    const x = qt();
+    for (const J of Object.keys(t?.resources?.components ?? {}).filter(
+      ($) => l.includes($)
+    )) {
+      const $ = t.resources?.components?.[J]?.component;
+      if ($ && $.renderer?.type === "react-component") {
+        const K = $.renderer?.chunks ?? [];
+        if (K?.length > 0)
+          for (const pe of K) {
+            const Pe = E(v, pe), le = x?.[pe];
+            try {
+              le && U(le) && !U(Pe) && ot(le, Pe);
+            } catch (He) {
+              f.error(`copy chunk ${pe} error`, He.message);
+            }
+          }
+      }
+    }
+  }
+  return g;
+}
+async function Be(t, { importAssets: e, includeResources: s } = {}) {
+  if (!U(t))
+    return null;
+  let a, o = !1;
+  try {
+    B(t).isDirectory() ? a = t : /\.(tgz|gz|tar)$/.test(t) && (o = !0, a = _e(), await St({ file: t, C: a }));
+    const r = te("**/.blocklet/pages/pages.config.yml", { cwd: a, absolute: !0 }).at(0), i = r && E(L(r), "../../pages"), c = r && E(L(r), "../../components"), l = r && E(L(r), "../../routes");
+    if (!r)
+      return null;
+    const m = G.parse(H(r).toString()), T = (h, u, y) => {
+      let w = E(h, `${u}${y ? `.${y}` : ""}.yml`);
+      return (!U(w) || !B(w).isFile()) && (w = E(h, u, `index${y ? `.${y}` : ""}.yml`), !U(w) || !B(w)) ? null : G.parse(H(w).toString());
+    }, O = (h, u) => {
+      try {
+        const y = te(`*.${u}.yml`, { cwd: h, absolute: !0 })[0];
+        return y ? G.parse(H(y).toString()) : null;
+      } catch (y) {
+        f.error("parse component error", y);
+      }
+      return null;
+    }, b = (h, u) => {
+      let y = E(h, `${u}.yml`);
+      return (!U(y) || !B(y).isFile()) && (y = E(h, u, "index.yml"), !U(y) || !B(y)) ? null : G.parse(H(y).toString());
+    }, d = R(
+      m.pages.map(({ slug: h }) => {
+        const u = R(
+          m.supportedLocales.map(({ locale: A }) => {
+            const n = i ? T(i, oe(h), A) : void 0;
+            if (n)
+              return { locale: A, page: n };
+            const S = i ? T(i, h, A) : void 0;
+            return S && { locale: A, page: S };
+          })
+        ), y = u[0]?.page;
+        if (!y)
+          return null;
+        const w = y.sections.map(it);
+        return {
+          id: y.id || Oe(),
+          createdAt: y.createdAt,
+          updatedAt: y.updatedAt,
+          publishedAt: y.publishedAt,
+          isPublic: y.isPublic ?? !0,
+          templateConfig: y.templateConfig,
+          slug: h,
+          sections: Object.fromEntries(w.map((A) => [A.id, A])),
+          sectionIds: w.map((A) => A.id),
+          locales: Object.fromEntries(u.map(({ locale: A, page: n }) => [A, n.meta])),
+          dataSource: y.dataSource ? Object.fromEntries(
+            // 获取 dataSource 中所有 section ID
+            [...new Set(u.flatMap(({ page: A }) => Object.keys(A.dataSource ?? {})))].map((A) => [
+              A,
+              Object.fromEntries(
+                u.map(({ locale: n, page: S }) => {
+                  const v = S.dataSource?.[A];
+                  return [n, v || {}];
+                })
+              )
+            ])
+          ) : Object.fromEntries(
+            // 获取所有 section ID
+            [...new Set(u.flatMap(({ page: A }) => A.sections.map((n) => n.id)))].map((A) => [
+              A,
+              Object.fromEntries(
+                u.map(({ locale: n, page: S }) => {
+                  const v = S.dataSource?.[A];
+                  if (v)
+                    return [n, v];
+                  const x = S.sections.find((J) => J.id === A);
+                  return [n, x?.properties || {}];
+                })
+              )
+            ])
+          )
+        };
+      })
+    ), p = R(
+      m?.routes?.map(({ path: h }) => {
+        const u = l ? b(l, oe(h)) : void 0;
+        return {
+          ...u,
+          id: u?.id || Oe(),
+          createdAt: u?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: u?.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          publishedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+          path: u?.path ?? `/${u?.id}`,
+          params: u?.params,
+          handler: u?.handler ?? "Pages Kit",
+          isPublic: u?.isPublic ?? !0,
+          enabledGenerate: u?.enabledGenerate ?? !1,
+          displayTemplateId: u?.displayTemplateId ?? void 0,
+          dataSource: u?.dataSource ?? {}
+        };
+      }) ?? []
+    ), g = c ? R(m.components?.map(({ id: h }) => O(c, h)) ?? []) : [];
+    if (e) {
+      const h = (...u) => {
+        f.info(`[${o ? j(t) : j(E(t, "../../../../"))}] importAssets:`, ...u);
+      };
+      try {
+        h("wait image-bin api ready"), await It({
+          resources: [`${pt(Ye)}/api/sdk/uploads`],
+          validateStatus: (w) => w >= 200 && w <= 500
+        }), h("image-bin api is ready");
+        const u = {}, y = {};
+        h("start to upload assets"), await Promise.allSettled([
+          Re(g, u, {
+            getFilePath: (w) => c && E(c, w),
+            onFinish: (w) => {
+              h(`upload ${w.length} component assets`);
+            }
+          }),
+          Re(d, y, {
+            getFilePath: (w, A) => {
+              const n = Ie(d, A.slice(0, 1));
+              return i && E(i, L(n.slug), w);
+            },
+            onFinish: (w) => {
+              h(`upload ${w.length} page assets`);
+            }
+          })
+        ]), h("upload assets done"), ye.clear(), global.gc && global.gc();
+      } catch (u) {
+        h("Error during asset import:", u);
+      }
+    }
+    const P = {};
+    if (s) {
+      const h = r && E(L(r), "../../resources/components"), u = R(
+        m.resources?.components?.map(({ id: y }) => O(h, y)) ?? []
+      );
+      u.length > 0 && (P.components = Object.fromEntries(
+        u.map((y, w) => [y.id, { index: w, component: y }])
+      ));
+    }
+    return {
+      supportedLocales: m.supportedLocales,
+      pageIds: d.map((h) => h.id),
+      components: Object.fromEntries(g.map((h, u) => [h.id, { index: u, data: h }])),
+      pages: Object.fromEntries(d.map((h) => [h.id, h])),
+      config: m.config || {},
+      resources: P,
+      routeIds: p.map((h) => h.id),
+      routes: Object.fromEntries(p.map((h) => [h.id, h])),
+      dataSourceIds: [],
+      dataSources: {}
+    };
+  } finally {
+    o && a && $e(a, { force: !0, recursive: !0 });
+  }
+}
+async function je(t, e, {
+  routes: s,
+  mergeMode: a = "byUpdateTime",
+  deleteRoutes: o = !1,
+  publishMode: r = void 0
+} = {}) {
+  try {
+    r && We(r);
+  } catch (b) {
+    f.error("clear preload page cache error", { error: b });
+  }
+  const { pages: i, pageIds: c, routeIds: l, routes: m, supportedLocales: T } = t;
+  if (r === "production") {
+    let b = s ?? [], d = null;
+    for (const p of l ?? []) {
+      const g = m?.[p];
+      if (g?.params && g?.params.length > 0 && g?.paramsOptions && g?.paramsOptions.length > 0) {
+        const P = Se({
+          basePath: g.path,
+          params: g.params,
+          routeId: g.id,
+          paramsOptions: g.paramsOptions,
+          currentIndex: 0,
+          currentParams: [],
+          currentOptionIds: [],
+          result: []
+        }), h = Object.fromEntries(P.map((u) => [`${p}-${u.paramOptionIds.join("-")}`, u]));
+        d = { ...d || {}, ...h }, s || (b = [...b, ...P.map((u) => `${p}-${u.paramOptionIds.join("-")}`)]);
+      } else s || b.push(p);
+    }
+    f.info("routeIds to be published: ", b);
+    for (const p of b) {
+      let g = p;
+      if (g.includes("-")) {
+        const [u] = g.split("-");
+        g = u;
+      }
+      const P = m?.[g];
+      if (!P) {
+        const u = e.pageIds.indexOf(g);
+        u !== -1 && o && (e.pageIds.splice(u, 1), delete e.pages[g]);
+        for (const y of e.pageIds)
+          y.includes(`${g}-`) && (e.pageIds.splice(e.pageIds.indexOf(y), 1), delete e.pages[y]);
+        f.info("delete main route page", g);
+        continue;
+      }
+      if (p.includes("-") && !d?.[p]) {
+        const u = e.pageIds.indexOf(p);
+        u !== -1 && o && (e.pageIds.splice(u, 1), delete e.pages[p]), f.info("delete page", p);
+        continue;
+      }
+      if (!P.displayTemplateId) {
+        f.info("no display template", p);
+        continue;
+      }
+      const h = i[P.displayTemplateId];
+      if (!h) {
+        f.info("no template page", p);
+        continue;
+      }
+      if (e.pageIds.includes(p)) {
+        if (f.info("has need update page", p), a === "replace")
+          e.pages[p] = ue({
+            page: h,
+            route: P,
+            state: t,
+            routeId: p,
+            routePathInfo: d?.[p]
+          }), f.info("replace page", p);
+        else if (a === "byUpdateTime") {
+          const u = e.pages[P.id];
+          (!u || P.updatedAt && P.updatedAt > u.updatedAt) && (e.pages[p] = ue({
+            page: h,
+            route: P,
+            state: t,
+            routeId: p,
+            routePathInfo: d?.[p]
+          }), f.info("replace page by update time", p));
+        }
+      } else
+        e.pageIds.push(p), e.pages[p] = ue({
+          page: h,
+          route: P,
+          state: t,
+          routeId: p,
+          routePathInfo: d?.[p]
+        }), f.info("add page", p);
+    }
+    if (o && !s)
+      for (const p of e.pageIds)
+        b?.includes(p) || (delete e.pages[p], f.info("delete page", p)), e.pageIds = [...e.pageIds].filter((g) => b?.includes(g));
+  } else {
+    for (const b of c) {
+      const d = i[b];
+      if (d)
+        if (e.pageIds.includes(d.id)) {
+          if (a === "replace")
+            e.pages[d.id] = d;
+          else if (a === "byUpdateTime") {
+            const p = e.pages[d.id];
+            (!p || d.updatedAt && d.updatedAt > p.updatedAt) && (e.pages[d.id] = d);
+          }
+        } else
+          e.pageIds.push(d.id), e.pages[d.id] = d;
+    }
+    for (const b of l) {
+      const d = m[b];
+      if (d)
+        if (e.routeIds.includes(d.id)) {
+          if (a === "replace")
+            e.routes[d.id] = d;
+          else if (a === "byUpdateTime") {
+            const p = e.routes[d.id];
+            (!p || d.updatedAt && d.updatedAt > p.updatedAt) && (e.routes[d.id] = d);
+          }
+        } else
+          e.routeIds.push(d.id), e.routes[d.id] = d;
+    }
+  }
+  if (e.supportedLocales.splice(0, e.supportedLocales.length), e.supportedLocales.push(...ft(T)), o)
+    for (const b of Object.keys(e.components))
+      delete e.components[b];
+  let O = JSON.parse(JSON.stringify(t.components));
+  O = Object.fromEntries(
+    await Promise.all(
+      Object.entries(O).map(async ([b, d]) => {
+        const p = await Ge(d?.data);
+        return [
+          b,
+          {
+            ...d,
+            data: p
+          }
+        ];
+      })
+    )
+  ), Object.assign(e.components, O), Object.assign(e.config, JSON.parse(JSON.stringify(t.config))), Ee(t.resources.components) || (e.resources.components = JSON.parse(JSON.stringify(t.resources.components || {})));
+}
+const Ge = Qe(
+  async (t) => {
+    if (!Ee(t?.properties))
+      return t;
+    if (t?.renderer?.type === "react-component") {
+      const { script: e, PROPERTIES_SCHEMA: s } = t?.renderer || {};
+      if (s || e && e.includes("PROPERTIES_SCHEMA"))
+        try {
+          const a = await Xe(
+            e ?? "",
+            "PROPERTIES_SCHEMA",
+            t.id,
+            s
+          );
+          a && a.length > 0 && t && (t.properties = {}, a.forEach((o, r) => {
+            t?.properties && (t.properties[o.id] = {
+              index: r,
+              data: o
+            });
+          }));
+        } catch (a) {
+          f.error("getPropertiesFromCode error", { componentId: t.id, name: t.name }, { error: a });
+        }
+    }
+    return t;
+  },
+  {
+    subdir: "getPropertiesFromCode"
+  }
+);
+let re, Q, ne, ie;
+const Ve = () => lt({
+  types: [
+    { did: Fe, type: Te },
+    { did: Tt, type: Te }
+  ]
+}), qt = () => {
+  const t = Ve(), e = {};
+  return t.forEach((s) => {
+    const a = te("**/.blocklet/pages/pages.config.yml", { cwd: s.path, absolute: !0 }).at(0), o = a && E(L(a), "../../chunks");
+    if (o && U(o)) {
+      const r = rt(o);
+      for (const i of r)
+        e[i] = E(o, i);
+    }
+  }), e;
+};
+function ze() {
+  return re = (async () => {
+    const t = Ve();
+    Q = (await Promise.all(
+      t.map(async (s) => {
+        const a = s.path ? await Be(s.path, { importAssets: !1 }) : void 0;
+        return a ? { blockletId: s.did, state: a, blockletTitle: s.title } : void 0;
+      })
+    )).filter((s) => !!s), ne = Q.reduce(
+      (s, a) => Object.assign(
+        s,
+        Object.fromEntries(
+          Object.values(a.state.pages).map((o) => o ? [o?.id, { page: o, blockletId: a.blockletId }] : [])
+        )
+      ),
+      {}
+    );
+    const e = Q.reduce(
+      (s, a) => Object.assign(
+        s,
+        Object.fromEntries(
+          Object.values(a.state.components).map((o) => [o.data.id, { blockletId: a.blockletId, component: o.data }])
+        )
+      ),
+      {}
+    );
+    ie = Object.fromEntries(
+      await Promise.all(
+        Object.entries(e).map(async ([s, a]) => {
+          const o = await Ge(a.component);
+          return [
+            s,
+            {
+              ...a,
+              component: o
+            }
+          ];
+        })
+      )
+    );
+  })(), re;
+}
+function Ht(t) {
+  const e = Ue(
+    async () => {
+      await ze().catch((s) => {
+        f.error("load resource states error", { error: s });
+      }), await t?.({
+        states: Q,
+        pages: ne,
+        components: ie
+      });
+    },
+    3e3,
+    // 3s
+    { leading: !1, trailing: !0 }
+  );
+  return e(), I.events.on(I.Events.componentAdded, e), I.events.on(I.Events.componentRemoved, e), I.events.on(I.Events.componentStarted, e), I.events.on(I.Events.componentStopped, e), I.events.on(I.Events.componentUpdated, e), I.events.on(he, e), () => {
+    I.events.off(I.Events.componentAdded, e), I.events.off(I.Events.componentRemoved, e), I.events.off(I.Events.componentStarted, e), I.events.off(I.Events.componentStopped, e), I.events.off(I.Events.componentUpdated, e), I.events.off(he, e);
+  };
+}
+const Je = Symbol.for("GLOBAL_RESOURCE_STATES_LISTENER_KEY"), Ke = Symbol.for("GLOBAL_ENV_UPDATE_LISTENER_KEY"), ce = globalThis;
+ce[Je]?.();
+ce[Je] = Ht(async ({ pages: t, components: e }) => {
+  const s = await C.getProjectIds();
+  f.info(`start update resource states projects(${s.length})`, s), await Promise.race([
+    new Promise((a) => {
+      setTimeout(() => {
+        a({});
+      }, 30 * 1e3);
+    }),
+    Promise.all(
+      s.map(async (a) => {
+        qe({
+          projectId: a,
+          pages: t,
+          components: e
+        });
+      })
+    )
+  ]).catch((a) => {
+    f.error("update resource states failed:", a);
+  });
+});
+ce[Ke]?.();
+ce[Ke] = () => {
+  const t = () => {
+    C.pageUrlMapCache.clear(), f.info("[Cache CLEAR ALL] clear all page url map cache by env update");
+  };
+  return I.events.on(I.Events.envUpdate, t), () => {
+    I.events.off(I.Events.envUpdate, t);
+  };
+};
+C.startPeriodicCheck();
+process.on("beforeExit", () => {
+  C.stopPeriodicCheck();
+});
+process.on("SIGINT", () => {
+  C.stopPeriodicCheck(), process.exit(0);
+});
+process.on("SIGTERM", () => {
+  C.stopPeriodicCheck(), process.exit(0);
+});
+async function qe({
+  projectId: t,
+  pages: e,
+  components: s
+}) {
+  const a = C.sharedInstances[t];
+  if (!a) {
+    f.info(`projectId: ${t} not found in sharedInstances`);
+    return;
+  }
+  if (a.syncedStore.resources.pages = e, (await M.findByPk(t))?.useAllResources)
+    a.syncedStore.resources.components = s;
+  else {
+    const i = (await we.findAll({ where: { projectId: t } })).map((l) => l.componentId), c = Object.fromEntries(
+      Object.entries(s || {}).filter(([l]) => i.includes(l))
+    );
+    a.syncedStore.resources.components = c;
+  }
+  f.info(`update [${t}] resource states:`, {
+    pages: Object.keys(a.syncedStore.resources.pages || {}).length,
+    components: Object.keys(a.syncedStore.resources.components || {}).length
+  });
+}
+async function ks() {
+  f.info("trigger reload all project resource"), I.events.emit(he);
+}
+async function Ts({
+  ensureLoaded: t = !0
+} = {}) {
+  return t && (re ??= ze(), await re), { states: Q, pages: ne, components: ie };
+}
+export {
+  Fe as C,
+  M as P,
+  Te as R,
+  C as S,
+  q as a,
+  Os as b,
+  vs as c,
+  Gt as d,
+  zt as e,
+  Jt as f,
+  Ts as g,
+  Be as h,
+  Ht as i,
+  ks as j,
+  je as m,
+  Kt as t
+};