@blocklet/pages-kit-inner-components 0.7.2 → 0.7.4

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

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