@blocklet/pages-kit-inner-components 0.6.83 → 0.6.85

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

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