@blocklet/pages-kit-inner-components 0.6.103 → 0.6.105

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

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