@blocklet/pages-kit-inner-components 0.7.3 → 0.7.5

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

@@ -0,0 +1,1989 @@
+import { d as Je, l as p, 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 be } from "@blocklet/pages-kit/utils/route";
+import Ae from "lodash/cloneDeep";
+import { DataTypes as P, Sequelize as ht, Model as Ee, Op as Z } from "sequelize";
+import "sqlite3";
+import E from "@blocklet/sdk/lib/config";
+import { withoutTrailingSlash as Oe, withLeadingSlash as He, joinURL as x } 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 Re from "p-limit";
+import $e, { join as b, basename as $, dirname as M } from "path";
+import { nextId as Ue } 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 Rt } from "@blocklet/sdk/lib/component";
+import { reactive as Ct } from "@reactivedata/reactive";
+import { rename as Ne, mkdir as B, rm as Ke, writeFile as ne, lstat as oe, readFile as te, copyFile as jt, readdir as Dt } from "fs/promises";
+import { globSync as kt, glob as ye } from "glob";
+import * as fe from "lib0/decoding";
+import * as v from "lib0/encoding";
+import Ce 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 $t from "wait-on";
+import { Awareness as Ut, encodeAwarenessUpdate as _e, removeAwarenessStates as Nt, 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 Se = null;
+Se && clearInterval(Se);
+Se = setInterval(
+  async () => {
+    p.info("Start cleanupSqliteMemory"), await Gt(_, Je), p.info("End cleanupSqliteMemory");
+  },
+  60 * 1e3 * 10
+  // 10 minutes
+);
+const Vt = "z8iZiDFg3vkkrPwsiba1TLXy3H9XHzFERsP8o", xe = "page", we = "trigger-reload-project-resource", Ye = Vt, zt = "z2qa7BQdkEb3TwYyEYC1psK6uvmGnHSUHt5RM", qt = "z8iZiDFg3vkkrPwsiba1TLXy3H9XHzFERsP8o";
+class ke extends Ee {
+  // 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 U extends Ee {
+  static async getProjectByIdOrSlug(e, s) {
+    return e ? U.findOne({
+      where: {
+        [Z.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 U.findOne({
+      where: { slug: a }
+    });
+    return l && l?.id !== s ? Kt : null;
+  }
+}
+U.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 p.error("Failed to parse relatedBlocklets", { error: e, rawValue: t }), {};
+        }
+      },
+      set(t) {
+        try {
+          this.setDataValue("relatedBlocklets", t ? JSON.stringify(t) : "{}");
+        } catch (e) {
+          p.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 p.error("Failed to parse productionState", { error: e, rawValue: t }), {};
+        }
+      },
+      set(t) {
+        try {
+          this.setDataValue("productionState", t ? JSON.stringify(t) : "{}");
+        } catch (e) {
+          p.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: {
+            [Z.ne]: null
+          }
+        }
+      }
+    ]
+  }
+);
+U.hasMany(ke, {
+  foreignKey: "projectId",
+  as: "components"
+});
+async function G(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 = $e.join(t, a.name), n = $e.join(e, a.name);
+    a.isDirectory() ? await Qe(o, n) : await Xe(o, n);
+  }
+}
+async function Zs(t, e) {
+  (await z.promises.stat(t)).isDirectory() ? await Qe(t, e) : await Xe(t, e);
+}
+class ee extends Ee {
+}
+ee.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, f) => {
+    o && (l[x("/", o, i)] = {
+      ...f,
+      shouldRedirect: !0,
+      mainPage: !0
+    }), l[x("/", e, i)] = {
+      ...f,
+      shouldRedirect: !0,
+      mainPage: !0
+    };
+    for (const A of n) {
+      const R = { ...f, locale: A };
+      l[x("/", A, e, i)] = R, o && (l[x("/", A, o, i)] = R);
+    }
+  };
+  for (const i of a.pageIds || []) {
+    const f = a.pages?.[i];
+    if (!f || !f.isPublic)
+      continue;
+    const A = {
+      projectId: e,
+      projectSlug: o,
+      pageSlug: f.slug,
+      pageId: i,
+      defaultLocale: n?.[0],
+      locales: n,
+      publishedAt: a.config?.publishedAt,
+      isPublic: f.isPublic
+    };
+    r(f.slug, A);
+  }
+  return l;
+}
+async function Qt(t, e, s) {
+  const a = t.map((n) => n.urlPath), o = await ee.findAll({
+    where: {
+      urlPath: {
+        [Z.in]: a
+      },
+      projectId: {
+        [Z.ne]: e
+      }
+    },
+    attributes: ["urlPath", "projectId", "projectSlug", "pageSlug"],
+    transaction: s,
+    raw: !0
+  });
+  if (o.length > 0) {
+    p.warn(
+      `[URL Duplicate Warning] Found ${o.length} URL conflicts for project ${e}:`
+    );
+    for (const n of o) {
+      const l = t.find((r) => r.urlPath === n.urlPath);
+      if (l) {
+        const r = n.projectSlug ? x(n.projectSlug, n.pageSlug) : n.pageSlug;
+        p.warn(
+          `  - URL "${n.urlPath}" conflicts with project ${n.projectId} (${r}). Current project trying to use same URL for page: ${l.pageSlug}`
+        );
+      }
+    }
+    p.warn(
+      "[URL Duplicate Warning] These duplicate URLs will be ignored during save. Consider using different project slugs or page slugs to avoid conflicts."
+    );
+  }
+}
+async function Zt(t) {
+  const { projectId: e, transaction: s } = t;
+  try {
+    await ee.destroy({
+      where: { projectId: e },
+      transaction: s
+    });
+    const a = Xt(t), o = Object.entries(a).map(([n, l]) => ({
+      projectId: e,
+      urlPath: n,
+      projectSlug: l.projectSlug,
+      pageSlug: l.pageSlug,
+      pageId: l.pageId,
+      routeId: l.routeId,
+      locale: l.locale,
+      defaultLocale: l.defaultLocale,
+      shouldRedirect: l.shouldRedirect,
+      mainPage: l.mainPage,
+      isPublic: l.isPublic,
+      publishedAt: typeof l.publishedAt == "number" ? l.publishedAt : void 0,
+      locales: l.locales
+    }));
+    if (o.length > 0) {
+      await Qt(o, e, s);
+      const n = 100, l = [];
+      for (let r = 0; r < o.length; r += n) {
+        const i = o.slice(r, r + n);
+        l.push(
+          ee.bulkCreate(i, {
+            transaction: s,
+            ignoreDuplicates: !0
+            // 忽略重复数据，避免因脏数据导致整批插入失败
+          })
+        );
+      }
+      await Promise.all(l), p.info(`Regenerated ${o.length} URL mappings for project ${e}`);
+    }
+    return o.length;
+  } catch (a) {
+    throw p.error(`Failed to regenerate URL mappings for project ${e}:`, a), a;
+  }
+}
+function re(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(b(E.env.dataDir, "tmp-"));
+}
+function ie(t, e, s = []) {
+  return Array.isArray(t) ? t.flatMap((a, o) => ie(a, e, [...s, o])) : typeof t == "object" ? t === null ? [] : Object.entries(t).flatMap(([a, o]) => ie(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 es(t) {
+  t.pages && Object.keys(t.pages).forEach((s) => {
+    const a = J(t.pages[s]);
+    a && a instanceof F.Map && re(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 && re(n);
+      }
+    });
+  });
+}
+function ts(t) {
+  t.routes && Object.keys(t.routes).forEach((s) => {
+    const a = J(t.routes?.[s]);
+    a && a instanceof F.Map && re(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 && re(n);
+      }
+    });
+  });
+}
+function ss(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 = be({
+          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 me({
+  page: t,
+  route: e,
+  state: s,
+  routeId: a,
+  routePathInfo: o
+}) {
+  p.info(
+    `Executing datasource data assembly, routeId: ${a}, routePathInfo: ${JSON.stringify(o)}`
+  );
+  const n = {
+    ...Ae(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 as = 60 * 60 * 1e3, Y = new We({
+  max: 300,
+  ttl: as,
+  ttlResolution: 10 * 1e3,
+  // 10 seconds
+  allowStale: !0
+});
+function os(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++, p.info(`[Cache CLEAR] key: ${n}`);
+        break;
+      }
+      for (const r of e)
+        if (Fe(n, { currentPath: `/${r}${l}` })) {
+          Y.delete(n), s++, p.info(`[Cache CLEAR] key: ${n}`);
+          break;
+        }
+    }
+  return p.info(`[Cache CLEAR] cleared ${s} entries for paths:`, o), s;
+}
+function ns() {
+  const t = Y.size;
+  return Y.clear(), p.info(`[Cache CLEAR ALL] cleared ${t} entries`), t;
+}
+E.events.on(E.Events.envUpdate, ns);
+const { uploadToMediaKit: rs } = 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, is = 1e4, cs = 3e4, se = 0, ge = 1, ls = 0, ps = 1, Ie = E, W = b(process.env.BLOCKLET_DATA_DIR, "site-state"), ea = ["production", "draft"], ta = ["production"];
+function ce(t) {
+  return t?.replace(/\//g, "|") || "";
+}
+function us() {
+  const t = Ie.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 = Ct(
+      ft(
+        {
+          pages: {},
+          pageIds: [],
+          components: {},
+          supportedLocales: [],
+          config: {},
+          resources: {},
+          routeIds: [],
+          routes: {},
+          dataSourceIds: [],
+          dataSources: {}
+        },
+        this
+      )
+    ), this.initObserver(), this.on("update", this.updateHandler), this.awareness = new Ut(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 = b(W, e), a = b(W, `@del-${e}`);
+      await Ne(s, a);
+    } catch (s) {
+      p.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 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: b(W, e)
+    }), D.sharedInstances[e] = s, s);
+  }
+  // 轻量级 production 状态获取，不加载 draft 数据
+  static async getProductionState(e) {
+    const s = await U.findByPk(e, {
+      attributes: ["productionState"]
+    });
+    if (De(s?.productionState)) {
+      const a = b(W, e, "production"), o = await tt(a, { includeResources: !0 }) ?? us();
+      if (!o?.config?.defaultLocale) {
+        o.config ??= {};
+        const n = Ie.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 = $(this.options.path);
+    delete D.sharedInstances[e], super.destroy();
+  }
+  initObserver() {
+    es(this.syncedStore), ts(this.syncedStore);
+  }
+  get draftYjsFilePath() {
+    return b(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 = $(this.options.path);
+    return D.getProductionState(s);
+  }
+  async setState(e, s) {
+    const a = await gs(s, { exportAssets: !1, includeResources: !0 }), o = this.getPublishDir(e);
+    if (await B(M(o), { recursive: !0 }), await Ke(o, { force: !0, recursive: !0 }), await Ne(a, o), e === "production") {
+      const n = $(this.options.path), l = Ae(s);
+      await _.transaction(async (r) => {
+        await U.update({ productionState: l }, { where: { id: n }, transaction: r });
+        const i = await U.findByPk(n, {
+          attributes: ["slug"],
+          transaction: r
+        }), f = await Zt({
+          projectId: n,
+          projectSlug: i?.slug,
+          state: s,
+          transaction: r
+        });
+        p.info(`[SiteState] saved ${f} URL mappings for project ${n}`);
+      });
+    }
+  }
+  getPublishDir(e) {
+    return b(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((f) => {
+        i.add(f);
+      }), a.forEach((f) => {
+        i.delete(f);
+      }));
+    }
+    const l = v.createEncoder();
+    v.writeVarUint(l, ge), v.writeVarUint8Array(l, _e(this.awareness, n));
+    const r = v.toUint8Array(l);
+    this.conns.forEach((i, f) => this.send(f, r));
+  };
+  updateHandler = (e) => {
+    const s = v.createEncoder();
+    v.writeVarUint(s, se), _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 f = a[i];
+          r.has(f) ? (r.delete(f), i++) : a.splice(i, 1);
+        }
+      }
+      {
+        const r = new Set(Object.keys(n));
+        let i = 0;
+        for (; i < l.length; ) {
+          const f = l[i];
+          r.has(f) ? (r.delete(f), i++) : l.splice(i, 1);
+        }
+      }
+      e.splice(0, e.length), e.push(...Ie.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: f } = e[r];
+          i.has(f) ? e.splice(r, 1) : (r++, i.add(f));
+        }
+      }
+    });
+  };
+  send = (e, s) => {
+    e.readyState !== ls && e.readyState !== ps && 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 && Nt(this.awareness, Array.from(s), null);
+    }
+    e.close(), this.checkAndScheduleRelease();
+  };
+  // 检查并调度延迟释放
+  checkAndScheduleRelease() {
+    this.conns.size === 0 && this.scheduleRelease();
+  }
+  // 调度延迟释放
+  scheduleRelease() {
+    this.cancelRelease();
+    const e = $(this.options.path);
+    this.releaseTimer = setTimeout(() => {
+      p.info(`[SiteState] releasing instance due to no active connections: ${e}`), this.conns.size === 0 && (this.releaseTimer = void 0, this.destroy());
+    }, D.RELEASE_DELAY), p.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 = $(this.options.path);
+      p.info(`[SiteState] cancelled scheduled release for project ${e}`);
+    }
+  }
+  autoSave = Ce(async () => {
+    await B(M(this.draftYjsFilePath), { recursive: !0 }), await ne(this.draftYjsFilePath, F.encodeStateAsUpdate(this));
+  }, is);
+  save = ({ flush: e = !1 } = {}) => {
+    this.autoSave(), e && this.autoSave.flush();
+  };
+  publish = async ({ mode: e, routes: s }) => {
+    const a = $(this.options.path);
+    await Ss(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(), ss(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 = $(this.options.path), n = (await U.findByPk(a))?.slug || a;
+    let l = e;
+    (!l || l.length === 0) && (l = s.pageIds ?? []), p.info(`[SiteState] clearing page cache for project ${a}, routes:`, l || []);
+    const r = s.supportedLocales.map((A) => A.locale), i = [], f = l.filter((A) => s.pageIds?.includes(A));
+    for (const A of f) {
+      const y = s.pages[A].slug;
+      n && n !== a && (n === "/" ? i.push(y) : i.push(`/${n}${y}`)), i.push(`/${a}${y}`);
+    }
+    if (i.length > 0)
+      try {
+        const A = os(i, r);
+        p.info(`[SiteState] cleared ${A} 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);
+        }
+      }
+    }, cs);
+    e.on("close", () => {
+      this.closeConn(e), clearInterval(a);
+    }), e.on("pong", () => {
+      s = !0;
+    });
+    {
+      const o = v.createEncoder();
+      v.writeVarUint(o, se), 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, ge), 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 = fe.createDecoder(s), n = fe.readVarUint(o);
+      switch (n) {
+        case se:
+          v.writeVarUint(a, se), xt(o, a, this, null), v.length(a) > 1 && (this.ensureDataStructure(), this.send(e, v.toUint8Array(a)));
+          break;
+        case ge: {
+          Mt(this.awareness, fe.readVarUint8Array(o), e);
+          break;
+        }
+        default:
+          p.warn(`Unsupported messageType ${n}`);
+      }
+    } catch (a) {
+      p.error(a);
+    }
+    this.save();
+  };
+  // 这个方法还是需要动态的，因为可能会动态修改 projectSlug、语言之类的
+  static async pageUrlMap(e, s) {
+    if (p.info(`[SiteState] get pageUrlMap, mode: ${e}, projectId: ${s}`), e === "production") {
+      const n = s ? { projectId: s } : {}, l = await ee.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 p.info(`[SiteState] loaded ${l.length} URL mappings from database`), r;
+    }
+    let a = [];
+    s ? a = [s] : a = await this.getProjectIds();
+    let o = {};
+    if (a?.length) {
+      p.info("[SiteState] find project infos from database, projectIds: ", a);
+      const n = 30, l = Re(5);
+      for (let r = 0; r < a.length; r += n) {
+        const i = a.slice(r, r + n);
+        p.info(`[SiteState] processing project batch ${r / n + 1}, ids: `, i);
+        const f = await U.findAll({
+          where: {
+            id: {
+              [Z.in]: i
+            }
+          },
+          attributes: {
+            exclude: ["relatedBlocklets"]
+          }
+        });
+        await Promise.all(
+          f?.map(
+            (A) => l(async () => {
+              const R = A.id, y = A.slug || R, g = {}, u = await D.getStateByProjectId({ projectId: A.id, mode: e, clone: !1 }), I = vt(
+                E.env.languages?.map((O) => O.code) || [],
+                u.supportedLocales?.map((O) => O.locale) || []
+              ), C = (O, w) => {
+                y && (g[x("/", y, O)] = {
+                  ...w,
+                  shouldRedirect: !0,
+                  mainPage: !0
+                }), g[x("/", R, O)] = {
+                  ...w,
+                  shouldRedirect: !0,
+                  mainPage: !0
+                };
+                for (const k of I) {
+                  const h = { ...w, locale: k };
+                  g[x("/", k, R, O)] = h, y && (g[x("/", k, y, O)] = h);
+                }
+              };
+              if (e === "draft")
+                for (const O of u.routeIds || []) {
+                  const w = u?.routes?.[O];
+                  if (!w) continue;
+                  if (w.params && w.params.length > 0) {
+                    const S = be({
+                      basePath: w.path,
+                      params: w.params,
+                      routeId: w.id,
+                      paramsOptions: w.paramsOptions,
+                      currentIndex: 0,
+                      currentParams: [],
+                      currentOptionIds: [],
+                      result: []
+                    });
+                    for (const c of S) {
+                      const d = c.path, m = {
+                        projectId: R,
+                        projectSlug: y,
+                        pageSlug: d,
+                        pageId: w.displayTemplateId || "",
+                        routeId: O,
+                        // default locale
+                        defaultLocale: I?.[0],
+                        locales: I,
+                        publishedAt: u.config.publishedAt,
+                        isPublic: w.isPublic && c?.routeMetaData?.isPublic
+                      };
+                      C(d, m);
+                    }
+                  }
+                  const k = w.path, h = {
+                    projectId: R,
+                    projectSlug: y,
+                    pageSlug: k,
+                    pageId: w.displayTemplateId || "",
+                    routeId: O,
+                    // default locale
+                    defaultLocale: I?.[0],
+                    locales: I,
+                    publishedAt: u.config.publishedAt,
+                    isPublic: w.isPublic
+                  };
+                  C(k, h);
+                }
+              for (const O of u.pageIds || []) {
+                const w = u.pages[O];
+                if (!w) continue;
+                const k = w.slug, h = A.slug || R, S = {
+                  projectId: R,
+                  projectSlug: h,
+                  pageSlug: k,
+                  pageId: O,
+                  // default locale
+                  defaultLocale: I?.[0],
+                  locales: I,
+                  publishedAt: u.config.publishedAt,
+                  isPublic: w.isPublic,
+                  templateConfig: w.templateConfig
+                };
+                C(k, S);
+              }
+              o = { ...o, ...g };
+            })
+          )
+        );
+      }
+    }
+    return p.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), p.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, p.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 (p.info(
+      `[SiteState] periodic check summary: total instances: ${e}, with connections: ${a.length}, without connections: ${s.length}`
+    ), s.length > 0) {
+      p.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 {
+          p.info(`[SiteState] releasing instance due to periodic check: ${n}`), l.destroy(), o++;
+        } catch (r) {
+          p.error(`[SiteState] failed to release instance ${n} during periodic check:`, r);
+        }
+      p.info(
+        `[SiteState] periodic check completed: ${o}/${s.length} instances released successfully`
+      );
+    } else e > 0 ? p.debug("[SiteState] periodic check: all instances have active connections") : p.debug("[SiteState] periodic check: no instances exist");
+  }
+}
+async function ds(t, e, s) {
+  if (!t || !await G(t) || !(await oe(t)).isFile())
+    return null;
+  let o = s[t];
+  return o || (o = (async () => {
+    try {
+      return (await rs({
+        filePath: t,
+        fileName: e
+      }))?.data?.filename;
+    } catch (n) {
+      return p.error(`Failed to upload asset ${t}:`, n), null;
+    }
+  })(), s[t] = o), o;
+}
+const fs = async (t, e) => {
+  const s = $(t), a = await Rt({
+    name: Ye,
+    path: x("/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}`);
+}, ms = async (t, e) => {
+  await Promise.all(
+    t.map(async (s) => {
+      try {
+        await fs(s, b(e, $(s)));
+      } catch (a) {
+        p.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 ae(t, e, s) {
+  const { getFilename: a, exportAssets: o } = s, n = b(e, a(t));
+  if (await B(M(n), { recursive: !0 }), await ne(n, q.stringify(t)), o) {
+    const r = ie(
+      t,
+      (i) => typeof i == "string" && (ve.test(i) || X.test(i))
+    ).map((i) => {
+      const f = je(t, i);
+      return et(f);
+    }).flat().filter(Boolean);
+    await ms(r, M(n));
+  }
+}
+const Pe = new We({
+  max: 100,
+  ttl: 1 * 60 * 1e3
+  // 1 minute
+});
+async function ze(t, e, s) {
+  const a = ie(
+    t,
+    (r) => typeof r == "string" && (ve.test(r) || X.test(r))
+  ), o = Re(2), n = a.map(
+    (r) => o(async () => {
+      try {
+        const i = je(t, r), f = et(i);
+        for (const A of f) {
+          const R = $(A), y = s.getFilePath(A, r), g = y ? `${y}:${R}` : R, u = Pe.get(g);
+          if (u) {
+            X.test(i) || Me(t, r, u);
+            return;
+          }
+          const I = await ds(y, R, e);
+          I && (X.test(i) || Me(t, r, I), Pe.set(g, I));
+        }
+      } catch (i) {
+        p.error(`Failed to process upload for path ${r.join(".")}:`, i.message || i.reason);
+      }
+    })
+  ), l = await Promise.allSettled(n);
+  s.onFinish?.(l);
+}
+async function gs(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, d]) => {
+    d.data?.renderer?.type === "component-template" && i.push(c);
+  });
+  const f = l === "all" ? t.routeIds : l, A = (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((d) => {
+        const m = c.sections?.[d];
+        return m && A(m);
+      })
+    ) : void 0
+    /** @deprecated 已经废弃，数据在 page.dataSource 中管理 */
+    // properties: section.locales?.[locale] ?? {},
+  }), R = (c, d) => ({
+    id: c.id,
+    createdAt: c.createdAt,
+    updatedAt: c.updatedAt,
+    publishedAt: c.publishedAt,
+    isPublic: c.isPublic ?? !0,
+    templateConfig: c.templateConfig,
+    meta: c.locales?.[d] ?? {},
+    sections: L(
+      c.sectionIds.map((m) => {
+        const j = c.sections[m];
+        return j && A(j);
+      })
+    ),
+    // 将 dataSource.sectionId.locale 转换为 dataSource.sectionId
+    dataSource: Object.fromEntries(
+      Object.entries(c.dataSource || {}).map(([m, j]) => [m, j?.[d] ?? {}])
+    )
+  }), y = (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
+  }), g = L(
+    f.map((c) => {
+      const d = t.routes[c];
+      return d && y(d);
+    })
+  ), u = L(
+    t.supportedLocales.map((c) => c.locale).flatMap(
+      (c) => r.map((d) => {
+        const m = t.pages[d];
+        return m && {
+          locale: c,
+          slug: m.slug,
+          page: R(m, c)
+        };
+      })
+    )
+  ), I = Ze(), C = b(I, "pages");
+  await B(C, { recursive: !0 });
+  const O = b(I, "components");
+  await B(O, { recursive: !0 });
+  const w = b(I, "routes");
+  await B(w, { recursive: !0 });
+  for (const { locale: c, slug: d, page: m } of u)
+    await ae(m, C, {
+      getFilename: () => `${ce(d) || "index"}.${c}.yml`,
+      exportAssets: e
+    });
+  for (const c of g)
+    await ae(c, w, {
+      // getFilename: () => `${sanitizeSlug(route.path)}.yml`,
+      getFilename: () => `${ce(c.path) || "index"}.yml`,
+      exportAssets: e
+    });
+  for (const c of i) {
+    const d = t.components[c]?.data;
+    d && await ae(d, O, {
+      getFilename: (m) => `${m.name || "unnamed"}.${m.id}.yml`,
+      exportAssets: e
+    });
+  }
+  const k = b(I, ".blocklet/pages/pages.config.yml");
+  await B(M(k), { recursive: !0 });
+  const h = {
+    pages: L(
+      r.map((c) => {
+        const d = t.pages[c];
+        return d && { id: c, slug: d.slug };
+      })
+    ),
+    routes: L(
+      f.map((c) => {
+        const d = t.routes[c];
+        return d && { id: c, path: d.path };
+      })
+    ),
+    components: L(
+      i.map((c) => {
+        const d = t.components[c]?.data;
+        return d && {
+          id: c,
+          name: d.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 ne(k, q.stringify(h));
+  const S = b(I, "config.source.json");
+  if (o && await ne(S, JSON.stringify(o)), n) {
+    const c = b(I, "resources"), d = b(c, "components");
+    await B(d, { recursive: !0 });
+    for (const N of Object.keys(t?.resources?.components ?? {}).filter(
+      (T) => i.includes(T)
+    )) {
+      const T = t.resources?.components?.[N]?.component;
+      T && await ae(T, d, {
+        getFilename: (V) => `${V.name || "unnamed"}.${V.id}.yml`,
+        exportAssets: e
+      });
+    }
+    const m = b(I, "chunks");
+    await B(m, { recursive: !0 });
+    const j = await hs();
+    for (const N of Object.keys(t?.resources?.components ?? {}).filter(
+      (T) => i.includes(T)
+    )) {
+      const T = t.resources?.components?.[N]?.component;
+      if (T && T.renderer?.type === "react-component") {
+        const V = T.renderer?.chunks ?? [];
+        if (V?.length > 0)
+          for (const H of V) {
+            const Te = b(m, H), de = j?.[H];
+            try {
+              de && await G(de) && !await G(Te) && await jt(de, Te);
+            } catch (ct) {
+              p.error(`copy chunk ${H} error`, ct.message);
+            }
+          }
+      }
+    }
+  }
+  return I;
+}
+async function tt(t, { importAssets: e, includeResources: s } = {}) {
+  if (!await G(t))
+    return null;
+  let a, o = !1;
+  try {
+    (await oe(t)).isDirectory() ? a = t : /\.(tgz|gz|tar)$/.test(t) && (o = !0, a = Ze(), await Lt({ file: t, C: a }));
+    const r = (await ye("**/.blocklet/pages/pages.config.yml", { cwd: a, absolute: !0 }))[0], i = r && b(M(r), "../../pages"), f = r && b(M(r), "../../components"), A = r && b(M(r), "../../routes");
+    if (!r)
+      return null;
+    const R = await te(r, "utf-8"), y = q.parse(R), g = async (h, S, c) => {
+      let d = b(h, `${S}${c ? `.${c}` : ""}.yml`);
+      if (!await G(d) && (d = b(h, S, `index${c ? `.${c}` : ""}.yml`), !await G(d)) || !(await oe(d)).isFile())
+        return null;
+      const j = await te(d, "utf-8");
+      return q.parse(j);
+    }, u = async (h, S) => {
+      try {
+        const d = (await ye(`*.${S}.yml`, { cwd: h, absolute: !0 }))[0];
+        if (!d) return null;
+        const m = await te(d, "utf-8");
+        return q.parse(m);
+      } catch (c) {
+        p.error("parse component error", c);
+      }
+      return null;
+    }, I = async (h, S) => {
+      let c = b(h, `${S}.yml`);
+      if (!await G(c) && (c = b(h, S, "index.yml"), !await G(c)) || !(await oe(c)).isFile())
+        return null;
+      const m = await te(c, "utf-8");
+      return q.parse(m);
+    }, C = L(
+      await Promise.all(
+        y.pages.map(async ({ slug: h }) => {
+          const S = L(
+            await Promise.all(
+              y.supportedLocales.map(async ({ locale: m }) => {
+                const j = i ? await g(i, ce(h), m) : void 0;
+                if (j)
+                  return { locale: m, page: j };
+                const N = i ? await g(i, h, m) : void 0;
+                return N && { locale: m, page: N };
+              })
+            )
+          ), c = S[0]?.page;
+          if (!c)
+            return null;
+          const d = c.sections.map(bt);
+          return {
+            id: c.id || Ue(),
+            createdAt: c.createdAt,
+            updatedAt: c.updatedAt,
+            publishedAt: c.publishedAt,
+            isPublic: c.isPublic ?? !0,
+            templateConfig: c.templateConfig,
+            slug: h,
+            sections: Object.fromEntries(d.map((m) => [m.id, m])),
+            sectionIds: d.map((m) => m.id),
+            locales: Object.fromEntries(S.map(({ locale: m, page: j }) => [m, j.meta])),
+            dataSource: c.dataSource ? Object.fromEntries(
+              // 获取 dataSource 中所有 section ID
+              [...new Set(S.flatMap(({ page: m }) => Object.keys(m.dataSource ?? {})))].map((m) => [
+                m,
+                Object.fromEntries(
+                  S.map(({ locale: j, page: N }) => {
+                    const T = N.dataSource?.[m];
+                    return [j, T || {}];
+                  })
+                )
+              ])
+            ) : Object.fromEntries(
+              // 获取所有 section ID
+              [...new Set(S.flatMap(({ page: m }) => m.sections.map((j) => j.id)))].map((m) => [
+                m,
+                Object.fromEntries(
+                  S.map(({ locale: j, page: N }) => {
+                    const T = N.dataSource?.[m];
+                    if (T)
+                      return [j, T];
+                    const V = N.sections.find((H) => H.id === m);
+                    return [j, V?.properties || {}];
+                  })
+                )
+              ])
+            )
+          };
+        })
+      )
+    ), O = L(
+      await Promise.all(
+        (y?.routes || []).map(async ({ path: h }) => {
+          const S = A ? await I(A, ce(h)) : void 0;
+          return {
+            ...S,
+            id: S?.id || Ue(),
+            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 = f ? L(
+      await Promise.all((y.components || []).map(async ({ id: h }) => u(f, h)))
+    ) : [];
+    if (e) {
+      const h = (...S) => {
+        p.info(`[${o ? $(t) : $(b(t, "../../../../"))}] importAssets:`, ...S);
+      };
+      try {
+        h("wait image-bin api ready"), await $t({
+          resources: [`${Et(ut)}/api/sdk/uploads`],
+          validateStatus: (d) => d >= 200 && d <= 500
+        }), h("image-bin api is ready");
+        const S = {}, c = {};
+        h("start to upload assets"), await Promise.allSettled([
+          ze(w, S, {
+            getFilePath: (d) => f && b(f, d),
+            onFinish: (d) => {
+              h(`upload ${d.length} component assets`);
+            }
+          }),
+          ze(C, c, {
+            getFilePath: (d, m) => {
+              const j = je(C, m.slice(0, 1));
+              return i && b(i, M(j.slug), d);
+            },
+            onFinish: (d) => {
+              h(`upload ${d.length} page assets`);
+            }
+          })
+        ]), h("upload assets done"), Pe.clear(), global.gc && global.gc();
+      } catch (S) {
+        h("Error during asset import:", S);
+      }
+    }
+    const k = {};
+    if (s) {
+      const h = r && b(M(r), "../../resources/components"), S = L(
+        await Promise.all(
+          (y.resources?.components || []).map(async ({ id: c }) => u(h, c))
+        )
+      );
+      S.length > 0 && (k.components = Object.fromEntries(
+        S.map((c, d) => [c.id, { index: d, component: c }])
+      ));
+    }
+    return {
+      supportedLocales: y.supportedLocales,
+      pageIds: C.map((h) => h.id),
+      components: Object.fromEntries(w.map((h, S) => [h.id, { index: S, data: h }])),
+      pages: Object.fromEntries(C.map((h) => [h.id, h])),
+      config: y.config || {},
+      resources: k,
+      routeIds: O.map((h) => h.id),
+      routes: Object.fromEntries(O.map((h) => [h.id, h])),
+      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 (y) {
+    p.error("clear preload page cache error", { error: y });
+  }
+  const { pages: l, pageIds: r, routeIds: i, routes: f, supportedLocales: A } = t;
+  if (n === "production") {
+    let y = s ?? [], g = null;
+    for (const u of i ?? []) {
+      const I = f?.[u];
+      if (I?.params && I?.params.length > 0 && I?.paramsOptions && I?.paramsOptions.length > 0) {
+        const C = be({
+          basePath: I.path,
+          params: I.params,
+          routeId: I.id,
+          paramsOptions: I.paramsOptions,
+          currentIndex: 0,
+          currentParams: [],
+          currentOptionIds: [],
+          result: []
+        }), O = Object.fromEntries(C.map((w) => [`${u}-${w.paramOptionIds.join("-")}`, w]));
+        g = { ...g || {}, ...O }, s || (y = [...y, ...C.map((w) => `${u}-${w.paramOptionIds.join("-")}`)]);
+      } else s || y.push(u);
+    }
+    p.info("routeIds to be published: ", y);
+    for (const u of y) {
+      let I = u;
+      if (I.includes("-")) {
+        const [w] = I.split("-");
+        I = w;
+      }
+      const C = f?.[I];
+      if (!C) {
+        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]);
+        p.info("delete main route page", I);
+        continue;
+      }
+      if (u.includes("-") && !g?.[u]) {
+        const w = e.pageIds.indexOf(u);
+        w !== -1 && o && (e.pageIds.splice(w, 1), delete e.pages[u]), p.info("delete page", u);
+        continue;
+      }
+      if (!C.displayTemplateId) {
+        p.info("no display template", u);
+        continue;
+      }
+      const O = l[C.displayTemplateId];
+      if (!O) {
+        p.info("no template page", u);
+        continue;
+      }
+      if (e.pageIds.includes(u)) {
+        if (p.info("has need update page", u), a === "replace")
+          e.pages[u] = me({
+            page: O,
+            route: C,
+            state: t,
+            routeId: u,
+            routePathInfo: g?.[u]
+          }), p.info("replace page", u);
+        else if (a === "byUpdateTime") {
+          const w = e.pages[C.id];
+          (!w || C.updatedAt && C.updatedAt > w.updatedAt) && (e.pages[u] = me({
+            page: O,
+            route: C,
+            state: t,
+            routeId: u,
+            routePathInfo: g?.[u]
+          }), p.info("replace page by update time", u));
+        }
+      } else
+        e.pageIds.push(u), e.pages[u] = me({
+          page: O,
+          route: C,
+          state: t,
+          routeId: u,
+          routePathInfo: g?.[u]
+        }), p.info("add page", u);
+    }
+    if (o && !s)
+      for (const u of e.pageIds)
+        y?.includes(u) || (delete e.pages[u], p.info("delete page", u)), e.pageIds = [...e.pageIds].filter((I) => y?.includes(I));
+  } else {
+    for (const y of r) {
+      const g = l[y];
+      if (g)
+        if (e.pageIds.includes(g.id)) {
+          if (a === "replace")
+            e.pages[g.id] = g;
+          else if (a === "byUpdateTime") {
+            const u = e.pages[g.id];
+            (!u || g.updatedAt && g.updatedAt > u.updatedAt) && (e.pages[g.id] = g);
+          }
+        } else
+          e.pageIds.push(g.id), e.pages[g.id] = g;
+    }
+    for (const y of i) {
+      const g = f[y];
+      if (g)
+        if (e.routeIds.includes(g.id)) {
+          if (a === "replace")
+            e.routes[g.id] = g;
+          else if (a === "byUpdateTime") {
+            const u = e.routes[g.id];
+            (!u || g.updatedAt && g.updatedAt > u.updatedAt) && (e.routes[g.id] = g);
+          }
+        } else
+          e.routeIds.push(g.id), e.routes[g.id] = g;
+    }
+  }
+  if (e.supportedLocales.splice(0, e.supportedLocales.length), e.supportedLocales.push(...Ae(A)), o)
+    for (const y of Object.keys(e.components))
+      delete e.components[y];
+  let R = JSON.parse(JSON.stringify(t.components));
+  R = Object.fromEntries(
+    await Promise.all(
+      Object.entries(R).map(async ([y, g]) => {
+        const u = await st(g?.data);
+        return [
+          y,
+          {
+            ...g,
+            data: u
+          }
+        ];
+      })
+    )
+  ), Object.assign(e.components, R), 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) {
+          p.error("getPropertiesFromCode error", { componentId: t.id, name: t.name }, { error: a });
+        }
+    }
+    return t;
+  },
+  {
+    subdir: "getPropertiesFromCode"
+  }
+);
+let le, Q, pe, ue;
+const at = () => Ot({
+  types: [
+    { did: Ye, type: xe },
+    { did: zt, type: xe }
+  ]
+}), hs = async () => {
+  const t = at(), e = {};
+  for (const s of t) {
+    const o = (await ye("**/.blocklet/pages/pages.config.yml", {
+      cwd: s.path,
+      absolute: !0
+    }))[0], n = o && b(M(o), "../../chunks");
+    if (n && await G(n)) {
+      const l = await Dt(n);
+      for (const r of l)
+        e[r] = b(n, r);
+    }
+  }
+  return e;
+};
+function ot() {
+  return le = (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), pe = 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 }])
+        )
+      ),
+      {}
+    );
+    ue = Object.fromEntries(
+      await Promise.all(
+        Object.entries(e).map(async ([s, a]) => {
+          const o = await st(a.component);
+          return [
+            s,
+            {
+              ...a,
+              component: o
+            }
+          ];
+        })
+      )
+    );
+  })(), le;
+}
+function ys(t) {
+  const e = Ce(
+    async () => {
+      await ot().catch((s) => {
+        p.error("load resource states error", { error: s });
+      }), await t?.({
+        states: Q,
+        pages: pe,
+        components: ue
+      });
+    },
+    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(we, 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(we, e);
+  };
+}
+const nt = Symbol.for("GLOBAL_RESOURCE_STATES_LISTENER_KEY"), rt = globalThis;
+rt[nt]?.();
+rt[nt] = ys(async ({ pages: t, components: e }) => {
+  const s = await D.getProjectIds();
+  p.info(`start update resource states projects(${s.length})`, s);
+  const a = Re(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) => {
+    p.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) {
+    p.info(`projectId: ${t} not found in sharedInstances`);
+    return;
+  }
+  const o = a.syncedStore.resources.pages, n = a.syncedStore.resources.components, l = await U.findByPk(t, {
+    attributes: { exclude: ["productionState", "relatedBlocklets"] }
+  });
+  let r;
+  if (l?.useAllResources)
+    r = s;
+  else {
+    const R = (await ke.findAll({ where: { projectId: t } })).map((y) => y.componentId);
+    r = Object.fromEntries(Object.entries(s || {}).filter(([y]) => R.includes(y)));
+  }
+  const i = !Ge(o, e), f = !Ge(n, r);
+  i || f ? a.transact(() => {
+    i && (a.syncedStore.resources.pages = e, p.info(`[${t}] pages resources updated: ${Object.keys(e || {}).length} pages`)), f && (a.syncedStore.resources.components = r, p.info(
+      `[${t}] components resources updated: ${Object.keys(r || {}).length} components`
+    ));
+  }) : p.info(`[${t}] resource states unchanged, skipping update`), p.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: f
+  });
+}
+const he = /* @__PURE__ */ new Map();
+async function Ss(t) {
+  if (!he.has(t)) {
+    const e = Ce(async (s) => it({
+      projectId: s,
+      pages: pe,
+      components: ue
+    }), 3e3);
+    he.set(t, e);
+  }
+  return he.get(t)(t);
+}
+async function sa() {
+  p.info("trigger reload all project resource"), E.events.emit(we);
+}
+async function aa({
+  ensureLoaded: t = !0
+} = {}) {
+  return t && (le ??= ot(), await le), { states: Q, pages: pe, components: ue };
+}
+export {
+  Ye as C,
+  U as P,
+  xe as R,
+  D as S,
+  W as a,
+  ea as b,
+  Zs as c,
+  ta as d,
+  us as e,
+  fs as f,
+  aa as g,
+  ms as h,
+  tt as i,
+  ys as j,
+  sa as k,
+  qe as m,
+  gs as t,
+  Ss as u
+};