@spfn/cms 0.1.0-alpha.64 → 0.1.0-alpha.66

package/dist/server.js

@@ -2,7 +2,7 @@
 import { cache } from "react";
 import { client } from "@spfn/core/client";
 
-// src/contracts/published-cache.ts
+// src/lib/contracts/published-cache.ts
 import { Type } from "@sinclair/typebox";
 var SectionData = Type.Object({
   section: Type.String(),
@@ -13,7 +13,7 @@ var SectionData = Type.Object({
 });
 var getPublishedCacheContract = {
   method: "GET",
-  path: "/cms/published-cache",
+  path: "/published-cache",
   query: Type.Object({
     sections: Type.Union([
       Type.String({ description: "\uB2E8\uC77C \uC139\uC158 \uC774\uB984 (\uC608: home)" }),
@@ -31,10 +31,10 @@ var getPublishedCacheContract = {
   ])
 };
 
-// src/helpers/locale.actions.ts
-import { cookies, headers } from "next/headers.js";
+// src/server/helpers/locale.actions.ts
+import { cookies, headers } from "next/headers";
 
-// src/cms.config.ts
+// src/server/config/cms.config.ts
 function getEnvVar(key, defaultValue) {
   return process.env[key] || defaultValue;
 }
@@ -62,10 +62,558 @@ function getCmsConfig() {
   return currentConfig;
 }
 
-// src/helpers/locale.constants.ts
+// src/lib/constants/locale.constants.ts
 var LOCALE_COOKIE_KEY = "spfn-locale";
+var LOCALE_INFO_MAP = {
+  // 한국어
+  ko: {
+    locale: "ko",
+    countryCode: "KR",
+    flag: "🇰🇷",
+    dialCode: "+82",
+    nativeName: "\uD55C\uAD6D\uC5B4",
+    englishName: "Korean",
+    currencyCode: "KRW",
+    dateFormat: "YYYY.MM.DD"
+  },
+  // 영어 (미국)
+  en: {
+    locale: "en",
+    countryCode: "US",
+    flag: "🇺🇸",
+    dialCode: "+1",
+    nativeName: "English",
+    englishName: "English",
+    currencyCode: "USD",
+    dateFormat: "MM/DD/YYYY"
+  },
+  // 일본어
+  ja: {
+    locale: "ja",
+    countryCode: "JP",
+    flag: "🇯🇵",
+    dialCode: "+81",
+    nativeName: "\u65E5\u672C\u8A9E",
+    englishName: "Japanese",
+    currencyCode: "JPY",
+    dateFormat: "YYYY/MM/DD"
+  },
+  // 중국어 (간체)
+  zh: {
+    locale: "zh",
+    countryCode: "CN",
+    flag: "🇨🇳",
+    dialCode: "+86",
+    nativeName: "\u7B80\u4F53\u4E2D\u6587",
+    englishName: "Chinese (Simplified)",
+    currencyCode: "CNY",
+    dateFormat: "YYYY-MM-DD"
+  },
+  // 중국어 (번체, 대만)
+  "zh-TW": {
+    locale: "zh-TW",
+    countryCode: "TW",
+    flag: "🇹🇼",
+    dialCode: "+886",
+    nativeName: "\u7E41\u9AD4\u4E2D\u6587",
+    englishName: "Chinese (Traditional)",
+    currencyCode: "TWD",
+    dateFormat: "YYYY/MM/DD"
+  },
+  // 스페인어
+  es: {
+    locale: "es",
+    countryCode: "ES",
+    flag: "🇪🇸",
+    dialCode: "+34",
+    nativeName: "Espa\xF1ol",
+    englishName: "Spanish",
+    currencyCode: "EUR",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 프랑스어
+  fr: {
+    locale: "fr",
+    countryCode: "FR",
+    flag: "🇫🇷",
+    dialCode: "+33",
+    nativeName: "Fran\xE7ais",
+    englishName: "French",
+    currencyCode: "EUR",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 독일어
+  de: {
+    locale: "de",
+    countryCode: "DE",
+    flag: "🇩🇪",
+    dialCode: "+49",
+    nativeName: "Deutsch",
+    englishName: "German",
+    currencyCode: "EUR",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 이탈리아어
+  it: {
+    locale: "it",
+    countryCode: "IT",
+    flag: "🇮🇹",
+    dialCode: "+39",
+    nativeName: "Italiano",
+    englishName: "Italian",
+    currencyCode: "EUR",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 포르투갈어 (브라질)
+  pt: {
+    locale: "pt",
+    countryCode: "BR",
+    flag: "🇧🇷",
+    dialCode: "+55",
+    nativeName: "Portugu\xEAs",
+    englishName: "Portuguese",
+    currencyCode: "BRL",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 러시아어
+  ru: {
+    locale: "ru",
+    countryCode: "RU",
+    flag: "🇷🇺",
+    dialCode: "+7",
+    nativeName: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439",
+    englishName: "Russian",
+    currencyCode: "RUB",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 아랍어
+  ar: {
+    locale: "ar",
+    countryCode: "SA",
+    flag: "🇸🇦",
+    dialCode: "+966",
+    nativeName: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629",
+    englishName: "Arabic",
+    rtl: true,
+    currencyCode: "SAR",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 힌디어
+  hi: {
+    locale: "hi",
+    countryCode: "IN",
+    flag: "🇮🇳",
+    dialCode: "+91",
+    nativeName: "\u0939\u093F\u0928\u094D\u0926\u0940",
+    englishName: "Hindi",
+    currencyCode: "INR",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 태국어
+  th: {
+    locale: "th",
+    countryCode: "TH",
+    flag: "🇹🇭",
+    dialCode: "+66",
+    nativeName: "\u0E44\u0E17\u0E22",
+    englishName: "Thai",
+    currencyCode: "THB",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 베트남어
+  vi: {
+    locale: "vi",
+    countryCode: "VN",
+    flag: "🇻🇳",
+    dialCode: "+84",
+    nativeName: "Ti\u1EBFng Vi\u1EC7t",
+    englishName: "Vietnamese",
+    currencyCode: "VND",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 인도네시아어
+  id: {
+    locale: "id",
+    countryCode: "ID",
+    flag: "🇮🇩",
+    dialCode: "+62",
+    nativeName: "Bahasa Indonesia",
+    englishName: "Indonesian",
+    currencyCode: "IDR",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 터키어
+  tr: {
+    locale: "tr",
+    countryCode: "TR",
+    flag: "🇹🇷",
+    dialCode: "+90",
+    nativeName: "T\xFCrk\xE7e",
+    englishName: "Turkish",
+    currencyCode: "TRY",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 폴란드어
+  pl: {
+    locale: "pl",
+    countryCode: "PL",
+    flag: "🇵🇱",
+    dialCode: "+48",
+    nativeName: "Polski",
+    englishName: "Polish",
+    currencyCode: "PLN",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 네덜란드어
+  nl: {
+    locale: "nl",
+    countryCode: "NL",
+    flag: "🇳🇱",
+    dialCode: "+31",
+    nativeName: "Nederlands",
+    englishName: "Dutch",
+    currencyCode: "EUR",
+    dateFormat: "DD-MM-YYYY"
+  },
+  // 중국어 (홍콩)
+  "zh-HK": {
+    locale: "zh-HK",
+    countryCode: "HK",
+    flag: "🇭🇰",
+    dialCode: "+852",
+    nativeName: "\u7E41\u9AD4\u4E2D\u6587 (\u9999\u6E2F)",
+    englishName: "Chinese (Hong Kong)",
+    currencyCode: "HKD",
+    dateFormat: "YYYY/MM/DD"
+  },
+  // 말레이어
+  ms: {
+    locale: "ms",
+    countryCode: "MY",
+    flag: "🇲🇾",
+    dialCode: "+60",
+    nativeName: "Bahasa Melayu",
+    englishName: "Malay",
+    currencyCode: "MYR",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 영어 (영국)
+  "en-GB": {
+    locale: "en-GB",
+    countryCode: "GB",
+    flag: "🇬🇧",
+    dialCode: "+44",
+    nativeName: "English (UK)",
+    englishName: "English (United Kingdom)",
+    currencyCode: "GBP",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 영어 (캐나다)
+  "en-CA": {
+    locale: "en-CA",
+    countryCode: "CA",
+    flag: "🇨🇦",
+    dialCode: "+1",
+    nativeName: "English (Canada)",
+    englishName: "English (Canada)",
+    currencyCode: "CAD",
+    dateFormat: "YYYY-MM-DD"
+  },
+  // 영어 (호주)
+  "en-AU": {
+    locale: "en-AU",
+    countryCode: "AU",
+    flag: "🇦🇺",
+    dialCode: "+61",
+    nativeName: "English (Australia)",
+    englishName: "English (Australia)",
+    currencyCode: "AUD",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 영어 (뉴질랜드)
+  "en-NZ": {
+    locale: "en-NZ",
+    countryCode: "NZ",
+    flag: "🇳🇿",
+    dialCode: "+64",
+    nativeName: "English (New Zealand)",
+    englishName: "English (New Zealand)",
+    currencyCode: "NZD",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 스페인어 (멕시코)
+  "es-MX": {
+    locale: "es-MX",
+    countryCode: "MX",
+    flag: "🇲🇽",
+    dialCode: "+52",
+    nativeName: "Espa\xF1ol (M\xE9xico)",
+    englishName: "Spanish (Mexico)",
+    currencyCode: "MXN",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 스페인어 (아르헨티나)
+  "es-AR": {
+    locale: "es-AR",
+    countryCode: "AR",
+    flag: "🇦🇷",
+    dialCode: "+54",
+    nativeName: "Espa\xF1ol (Argentina)",
+    englishName: "Spanish (Argentina)",
+    currencyCode: "ARS",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 스페인어 (콜롬비아)
+  "es-CO": {
+    locale: "es-CO",
+    countryCode: "CO",
+    flag: "🇨🇴",
+    dialCode: "+57",
+    nativeName: "Espa\xF1ol (Colombia)",
+    englishName: "Spanish (Colombia)",
+    currencyCode: "COP",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 스웨덴어
+  sv: {
+    locale: "sv",
+    countryCode: "SE",
+    flag: "🇸🇪",
+    dialCode: "+46",
+    nativeName: "Svenska",
+    englishName: "Swedish",
+    currencyCode: "SEK",
+    dateFormat: "YYYY-MM-DD"
+  },
+  // 노르웨이어
+  no: {
+    locale: "no",
+    countryCode: "NO",
+    flag: "🇳🇴",
+    dialCode: "+47",
+    nativeName: "Norsk",
+    englishName: "Norwegian",
+    currencyCode: "NOK",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 덴마크어
+  da: {
+    locale: "da",
+    countryCode: "DK",
+    flag: "🇩🇰",
+    dialCode: "+45",
+    nativeName: "Dansk",
+    englishName: "Danish",
+    currencyCode: "DKK",
+    dateFormat: "DD-MM-YYYY"
+  },
+  // 핀란드어
+  fi: {
+    locale: "fi",
+    countryCode: "FI",
+    flag: "🇫🇮",
+    dialCode: "+358",
+    nativeName: "Suomi",
+    englishName: "Finnish",
+    currencyCode: "EUR",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 우크라이나어
+  uk: {
+    locale: "uk",
+    countryCode: "UA",
+    flag: "🇺🇦",
+    dialCode: "+380",
+    nativeName: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430",
+    englishName: "Ukrainian",
+    currencyCode: "UAH",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 체코어
+  cs: {
+    locale: "cs",
+    countryCode: "CZ",
+    flag: "🇨🇿",
+    dialCode: "+420",
+    nativeName: "\u010Ce\u0161tina",
+    englishName: "Czech",
+    currencyCode: "CZK",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 헝가리어
+  hu: {
+    locale: "hu",
+    countryCode: "HU",
+    flag: "🇭🇺",
+    dialCode: "+36",
+    nativeName: "Magyar",
+    englishName: "Hungarian",
+    currencyCode: "HUF",
+    dateFormat: "YYYY.MM.DD."
+  },
+  // 루마니아어
+  ro: {
+    locale: "ro",
+    countryCode: "RO",
+    flag: "🇷🇴",
+    dialCode: "+40",
+    nativeName: "Rom\xE2n\u0103",
+    englishName: "Romanian",
+    currencyCode: "RON",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 불가리아어
+  bg: {
+    locale: "bg",
+    countryCode: "BG",
+    flag: "🇧🇬",
+    dialCode: "+359",
+    nativeName: "\u0411\u044A\u043B\u0433\u0430\u0440\u0441\u043A\u0438",
+    englishName: "Bulgarian",
+    currencyCode: "BGN",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 크로아티아어
+  hr: {
+    locale: "hr",
+    countryCode: "HR",
+    flag: "🇭🇷",
+    dialCode: "+385",
+    nativeName: "Hrvatski",
+    englishName: "Croatian",
+    currencyCode: "HRK",
+    dateFormat: "DD.MM.YYYY."
+  },
+  // 세르비아어
+  sr: {
+    locale: "sr",
+    countryCode: "RS",
+    flag: "🇷🇸",
+    dialCode: "+381",
+    nativeName: "\u0421\u0440\u043F\u0441\u043A\u0438",
+    englishName: "Serbian",
+    currencyCode: "RSD",
+    dateFormat: "DD.MM.YYYY."
+  },
+  // 슬로바키아어
+  sk: {
+    locale: "sk",
+    countryCode: "SK",
+    flag: "🇸🇰",
+    dialCode: "+421",
+    nativeName: "Sloven\u010Dina",
+    englishName: "Slovak",
+    currencyCode: "EUR",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 슬로베니아어
+  sl: {
+    locale: "sl",
+    countryCode: "SI",
+    flag: "🇸🇮",
+    dialCode: "+386",
+    nativeName: "Sloven\u0161\u010Dina",
+    englishName: "Slovenian",
+    currencyCode: "EUR",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 리투아니아어
+  lt: {
+    locale: "lt",
+    countryCode: "LT",
+    flag: "🇱🇹",
+    dialCode: "+370",
+    nativeName: "Lietuvi\u0173",
+    englishName: "Lithuanian",
+    currencyCode: "EUR",
+    dateFormat: "YYYY-MM-DD"
+  },
+  // 라트비아어
+  lv: {
+    locale: "lv",
+    countryCode: "LV",
+    flag: "🇱🇻",
+    dialCode: "+371",
+    nativeName: "Latvie\u0161u",
+    englishName: "Latvian",
+    currencyCode: "EUR",
+    dateFormat: "DD.MM.YYYY."
+  },
+  // 에스토니아어
+  et: {
+    locale: "et",
+    countryCode: "EE",
+    flag: "🇪🇪",
+    dialCode: "+372",
+    nativeName: "Eesti",
+    englishName: "Estonian",
+    currencyCode: "EUR",
+    dateFormat: "DD.MM.YYYY"
+  },
+  // 그리스어
+  el: {
+    locale: "el",
+    countryCode: "GR",
+    flag: "🇬🇷",
+    dialCode: "+30",
+    nativeName: "\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC",
+    englishName: "Greek",
+    currencyCode: "EUR",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 페르시아어
+  fa: {
+    locale: "fa",
+    countryCode: "IR",
+    flag: "🇮🇷",
+    dialCode: "+98",
+    nativeName: "\u0641\u0627\u0631\u0633\u06CC",
+    englishName: "Persian",
+    rtl: true,
+    currencyCode: "IRR",
+    dateFormat: "YYYY/MM/DD"
+  },
+  // 히브리어
+  he: {
+    locale: "he",
+    countryCode: "IL",
+    flag: "🇮🇱",
+    dialCode: "+972",
+    nativeName: "\u05E2\u05D1\u05E8\u05D9\u05EA",
+    englishName: "Hebrew",
+    rtl: true,
+    currencyCode: "ILS",
+    dateFormat: "DD/MM/YYYY"
+  },
+  // 스와힐리어
+  sw: {
+    locale: "sw",
+    countryCode: "KE",
+    flag: "🇰🇪",
+    dialCode: "+254",
+    nativeName: "Kiswahili",
+    englishName: "Swahili",
+    currencyCode: "KES",
+    dateFormat: "DD/MM/YYYY"
+  }
+};
+function getLocaleInfo(locale) {
+  return LOCALE_INFO_MAP[locale];
+}
+function getSupportedLocales() {
+  return Object.keys(LOCALE_INFO_MAP);
+}
+function getFlag(locale) {
+  return LOCALE_INFO_MAP[locale]?.flag ?? "";
+}
+function getDialCode(locale) {
+  return LOCALE_INFO_MAP[locale]?.dialCode ?? "";
+}
+function isRTL(locale) {
+  return LOCALE_INFO_MAP[locale]?.rtl ?? false;
+}
 
-// src/helpers/locale.actions.ts
+// src/server/helpers/locale.actions.ts
 async function detectBrowserLanguage() {
   try {
     const headersList = await headers();
@@ -104,9 +652,910 @@ async function getLocale() {
   return config.defaultLocale;
 }
 
+// src/server/helpers/sync.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { basename, extname, join } from "path";
+
+// src/server/labels/helpers.ts
+function flattenLabels(labels) {
+  const result = [];
+  function isLabelDefinition(obj) {
+    return "key" in obj && "defaultValue" in obj && typeof obj.key === "string" && (typeof obj.defaultValue === "string" || typeof obj.defaultValue === "object");
+  }
+  function traverse(obj) {
+    if (isLabelDefinition(obj)) {
+      result.push({
+        key: obj.key,
+        defaultValue: obj.defaultValue,
+        description: obj.description
+      });
+    } else {
+      Object.values(obj).forEach((value) => {
+        if (typeof value === "object" && value !== null) {
+          traverse(value);
+        }
+      });
+    }
+  }
+  traverse(labels);
+  return result;
+}
+function extractLabels(definition) {
+  return flattenLabels(definition.labels);
+}
+
+// src/server/repositories/cms-labels.repository.ts
+import { findOne, findMany as findManyHelper, create as createHelper, updateOne, deleteOne, count as countHelper } from "@spfn/core/db";
+import { desc } from "drizzle-orm";
+
+// src/server/entities/cms-labels.ts
+import { index, integer, serial, text, timestamp } from "drizzle-orm/pg-core";
+import { createFunctionSchema } from "@spfn/core/db";
+var schema = createFunctionSchema("@spfn/cms");
+var cmsLabels = schema.table("labels", {
+  // Primary Key
+  id: serial("id").primaryKey(),
+  // 라벨 식별자
+  key: text("key").notNull().unique(),
+  // 예: "home.hero.title", "why-futureplay.hero.subtitle"
+  // 구조: {section}.{component}.{property}
+  // 섹션 분류 (페이지 단위)
+  section: text("section").notNull(),
+  // 예: "home", "why-futureplay", "team"
+  // 값 타입
+  type: text("type").notNull(),
+  // "text" | "image" | "video" | "file" | "object"
+  // 기본값
+  defaultValue: text("default_value"),
+  // 라벨의 기본값 (sync 시 설정)
+  // 설명
+  description: text("description"),
+  // 라벨에 대한 설명 (optional)
+  // 현재 발행된 버전 번호
+  publishedVersion: integer("published_version"),
+  // null = 미발행 상태
+  // 1, 2, 3... = 발행된 버전 번호
+  // 생성자 추적
+  createdBy: text("created_by"),
+  // 타임스탬프
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // 인덱스: 섹션별 조회 최적화
+  index("cms_labels_section_idx").on(table.section),
+  // 인덱스: key로 조회 최적화 (unique 제약으로 자동 생성되지만 명시)
+  index("cms_labels_key_idx").on(table.key)
+]);
+
+// src/server/entities/cms-label-values.ts
+import { serial as serial2, integer as integer2, text as text2, jsonb, timestamp as timestamp2, index as index2, unique } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema2 } from "@spfn/core/db";
+var schema2 = createFunctionSchema2("@spfn/cms");
+var cmsLabelValues = schema2.table("label_values", {
+  // Primary Key
+  id: serial2("id").primaryKey(),
+  // Foreign Key: cms_labels
+  labelId: integer2("label_id").notNull().references(() => cmsLabels.id, { onDelete: "cascade" }),
+  // 버전 번호
+  version: integer2("version").notNull().default(1),
+  // 언어 코드
+  locale: text2("locale").notNull().default("ko"),
+  // "ko" | "en" | "ja"
+  // 반응형 브레이크포인트
+  breakpoint: text2("breakpoint"),
+  // null = 기본값 (모든 화면 크기)
+  // "sm" | "md" | "lg" | "xl" | "2xl"
+  // 실제 값 (JSONB)
+  value: jsonb("value").notNull(),
+  // LabelValue 타입:
+  // - TextValue: { type: "text", content: string }
+  // - ImageValue: { type: "image", url: string, alt?: string, width?: number, height?: number }
+  // - VideoValue: { type: "video", url: string, thumbnail?: string, duration?: number }
+  // - FileValue: { type: "file", url: string, filename: string, size?: number }
+  // - ObjectValue: { type: "object", fields: Record<string, LabelValue> }
+  // 생성 시각
+  createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // UNIQUE 제약: 같은 버전에서 locale + breakpoint 조합은 유일
+  unique("cms_label_values_locale_breakpoint_unique").on(table.labelId, table.version, table.locale, table.breakpoint),
+  // 인덱스: labelId + version 복합 조회 최적화
+  index2("cms_label_values_label_version_idx").on(table.labelId, table.version),
+  // 인덱스: locale 필터링 최적화
+  index2("cms_label_values_locale_idx").on(table.locale)
+]);
+
+// src/server/entities/cms-label-versions.ts
+import { serial as serial3, integer as integer3, text as text3, timestamp as timestamp3, index as index3, unique as unique2 } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema3 } from "@spfn/core/db";
+var schema3 = createFunctionSchema3("@spfn/cms");
+var cmsLabelVersions = schema3.table("label_versions", {
+  // Primary Key
+  id: serial3("id").primaryKey(),
+  // Foreign Key: cms_labels
+  labelId: integer3("label_id").notNull().references(() => cmsLabels.id, { onDelete: "cascade" }),
+  // 버전 번호
+  version: integer3("version").notNull(),
+  // 버전 상태
+  status: text3("status").notNull(),
+  // "draft" | "published" | "archived"
+  // 발행 정보
+  publishedAt: timestamp3("published_at", { withTimezone: true }),
+  publishedBy: text3("published_by"),
+  // 버전 노트 (변경사항 설명)
+  notes: text3("notes"),
+  // 버전 생성자
+  createdBy: text3("created_by"),
+  // 생성 시각
+  createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // UNIQUE 제약: 각 라벨의 버전 번호는 고유
+  unique2("cms_label_versions_label_version_unique").on(table.labelId, table.version),
+  // 인덱스: labelId로 버전 목록 조회 최적화
+  index3("cms_label_versions_label_id_idx").on(table.labelId),
+  // 인덱스: status 필터링 최적화
+  index3("cms_label_versions_status_idx").on(table.status)
+]);
+
+// src/server/entities/cms-draft-cache.ts
+import { serial as serial4, text as text4, jsonb as jsonb2, timestamp as timestamp4, index as index4, unique as unique3 } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema4 } from "@spfn/core/db";
+var schema4 = createFunctionSchema4("@spfn/cms");
+var cmsDraftCache = schema4.table("draft_cache", {
+  // Primary Key
+  id: serial4("id").primaryKey(),
+  // 섹션 (페이지 단위)
+  section: text4("section").notNull(),
+  // "home" | "why-futureplay" | "team" | "our-companies" | "apply"
+  // 언어
+  locale: text4("locale").notNull(),
+  // "ko" | "en" | "ja"
+  // 사용자 ID (핵심 필드!)
+  userId: text4("user_id").notNull(),
+  // 각 관리자의 독립적인 작업 공간
+  // Draft 콘텐츠 (JSONB)
+  content: jsonb2("content").notNull(),
+  // Record<string, LabelValue>
+  // {
+  //   "home.hero.title": { type: "text", content: "수정 중..." },
+  //   "home.hero.subtitle": { type: "text", content: "새로운 문구" },
+  //   ...
+  // }
+  // 최종 수정 시각
+  updatedAt: timestamp4("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // UNIQUE 제약: section + locale + userId 조합은 유일
+  unique3("cms_draft_cache_unique").on(table.section, table.locale, table.userId),
+  // 인덱스: section으로 조회 최적화
+  index4("cms_draft_cache_section_idx").on(table.section),
+  // 인덱스: userId로 사용자의 모든 draft 조회 최적화
+  index4("cms_draft_cache_user_idx").on(table.userId)
+]);
+
+// src/server/entities/cms-published-cache.ts
+import { serial as serial5, text as text5, jsonb as jsonb3, integer as integer4, timestamp as timestamp5, index as index5, unique as unique4 } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema5 } from "@spfn/core/db";
+var schema5 = createFunctionSchema5("@spfn/cms");
+var cmsPublishedCache = schema5.table("published_cache", {
+  // Primary Key
+  id: serial5("id").primaryKey(),
+  // 섹션 (페이지 단위)
+  section: text5("section").notNull(),
+  // "home" | "why-futureplay" | "team" | "our-companies" | "apply"
+  // 언어
+  locale: text5("locale").notNull(),
+  // "ko" | "en" | "ja"
+  // 캐시된 콘텐츠 (JSONB)
+  content: jsonb3("content").notNull(),
+  // Record<string, LabelValue>
+  // {
+  //   "home.hero.title": { type: "text", content: "..." },
+  //   "home.hero.image": { type: "image", url: "...", alt: "..." },
+  //   ...
+  // }
+  // 발행 정보
+  publishedAt: timestamp5("published_at", { withTimezone: true }).notNull(),
+  publishedBy: text5("published_by"),
+  // 캐시 버전 (클라이언트 캐싱용)
+  version: integer4("version").notNull().default(1)
+}, (table) => [
+  // UNIQUE 제약: section + locale 조합은 유일
+  unique4("cms_published_cache_unique").on(table.section, table.locale),
+  // 인덱스: section으로 조회 최적화
+  index5("cms_published_cache_section_idx").on(table.section)
+]);
+
+// src/server/entities/cms-audit-logs.ts
+import { serial as serial6, integer as integer5, text as text6, jsonb as jsonb4, timestamp as timestamp6, index as index6 } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema6 } from "@spfn/core/db";
+var schema6 = createFunctionSchema6("@spfn/cms");
+var cmsAuditLogs = schema6.table("audit_logs", {
+  // Primary Key
+  id: serial6("id").primaryKey(),
+  // Foreign Key: cms_labels (nullable - 라벨 삭제 시 로그는 유지)
+  labelId: integer5("label_id").references(() => cmsLabels.id, { onDelete: "set null" }),
+  // 작업 유형
+  action: text6("action").notNull(),
+  // "create" | "update" | "publish" | "unpublish" | "archive" | "delete" | "rollback" | "duplicate"
+  // 사용자 정보
+  userId: text6("user_id").notNull(),
+  userName: text6("user_name"),
+  // 변경 내용 (before/after)
+  changes: jsonb4("changes"),
+  // { before: {...}, after: {...} }
+  // 추가 메타데이터
+  metadata: jsonb4("metadata"),
+  // { version: number, ip: string, userAgent: string, ... }
+  // 작업 시각
+  createdAt: timestamp6("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // 인덱스: labelId로 이력 조회 최적화
+  index6("cms_audit_logs_label_id_idx").on(table.labelId),
+  // 인덱스: userId로 사용자 활동 조회 최적화
+  index6("cms_audit_logs_user_id_idx").on(table.userId),
+  // 인덱스: action 필터링 최적화
+  index6("cms_audit_logs_action_idx").on(table.action),
+  // 인덱스: 시간순 조회 최적화
+  index6("cms_audit_logs_created_at_idx").on(table.createdAt)
+]);
+
+// src/server/repositories/cms-labels.repository.ts
+async function findMany(options) {
+  const { section, limit = 20, offset = 0 } = options || {};
+  return findManyHelper(cmsLabels, {
+    where: section ? { section } : void 0,
+    orderBy: desc(cmsLabels.updatedAt),
+    limit,
+    offset
+  });
+}
+async function count(section) {
+  return countHelper(cmsLabels, section ? { section } : void 0);
+}
+async function findById(id) {
+  return findOne(cmsLabels, { id });
+}
+async function findByKey(key) {
+  return findOne(cmsLabels, { key });
+}
+async function findBySection(section) {
+  return findManyHelper(cmsLabels, {
+    where: { section },
+    orderBy: desc(cmsLabels.updatedAt)
+  });
+}
+async function create(data) {
+  return createHelper(cmsLabels, data);
+}
+async function updateById(id, data) {
+  return updateOne(cmsLabels, { id }, { ...data, updatedAt: /* @__PURE__ */ new Date() });
+}
+async function deleteById(id) {
+  return deleteOne(cmsLabels, { id });
+}
+var cmsLabelsRepository = {
+  findMany,
+  count,
+  findById,
+  findByKey,
+  findBySection,
+  create,
+  updateById,
+  deleteById
+};
+
+// src/server/repositories/cms-label-values.repository.ts
+import { findOne as findOne2, findMany as findMany2, create as create2, updateOne as updateOne2, deleteMany } from "@spfn/core/db";
+import { eq, and, isNull } from "drizzle-orm";
+async function findByLabelIdAndVersion(labelId, version, options) {
+  const { locale, breakpoint } = options || {};
+  const conditions = [
+    eq(cmsLabelValues.labelId, labelId),
+    eq(cmsLabelValues.version, version)
+  ];
+  if (locale) {
+    conditions.push(eq(cmsLabelValues.locale, locale));
+  }
+  if (breakpoint !== void 0) {
+    conditions.push(
+      breakpoint === null ? isNull(cmsLabelValues.breakpoint) : eq(cmsLabelValues.breakpoint, breakpoint)
+    );
+  }
+  return findMany2(cmsLabelValues, {
+    where: and(...conditions)
+  });
+}
+async function upsert(data) {
+  const existing = await findOne2(
+    cmsLabelValues,
+    and(
+      eq(cmsLabelValues.labelId, data.labelId),
+      eq(cmsLabelValues.version, data.version ?? 1),
+      eq(cmsLabelValues.locale, data.locale || "ko"),
+      data.breakpoint ? eq(cmsLabelValues.breakpoint, data.breakpoint) : isNull(cmsLabelValues.breakpoint)
+    )
+  );
+  if (existing) {
+    const updated = await updateOne2(
+      cmsLabelValues,
+      { id: existing.id },
+      { value: data.value }
+    );
+    return updated;
+  } else {
+    return create2(cmsLabelValues, data);
+  }
+}
+async function upsertMany(values) {
+  const results = [];
+  for (const value of values) {
+    const result = await upsert(value);
+    results.push(result);
+  }
+  return results;
+}
+async function deleteByVersion(labelId, version) {
+  return deleteMany(
+    cmsLabelValues,
+    and(
+      eq(cmsLabelValues.labelId, labelId),
+      eq(cmsLabelValues.version, version)
+    )
+  );
+}
+var cmsLabelValuesRepository = {
+  findByLabelIdAndVersion,
+  upsert,
+  upsertMany,
+  deleteByVersion
+};
+
+// src/server/repositories/cms-draft-cache.repository.ts
+import { findOne as findOne3, findMany as findMany3, deleteOne as deleteOne2, deleteMany as deleteMany2, upsert as upsertHelper } from "@spfn/core/db";
+import { eq as eq2, and as and2, lt } from "drizzle-orm";
+async function findByUser(section, locale, userId) {
+  return findOne3(
+    cmsDraftCache,
+    and2(
+      eq2(cmsDraftCache.section, section),
+      eq2(cmsDraftCache.locale, locale),
+      eq2(cmsDraftCache.userId, userId)
+    )
+  );
+}
+async function upsert2(data) {
+  return upsertHelper(cmsDraftCache, data, {
+    target: [cmsDraftCache.section, cmsDraftCache.locale, cmsDraftCache.userId],
+    set: {
+      content: data.content,
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  });
+}
+async function findAllByUser(userId) {
+  return findMany3(cmsDraftCache, {
+    where: eq2(cmsDraftCache.userId, userId)
+  });
+}
+async function deleteByUser(section, locale, userId) {
+  await deleteOne2(
+    cmsDraftCache,
+    and2(
+      eq2(cmsDraftCache.section, section),
+      eq2(cmsDraftCache.locale, locale),
+      eq2(cmsDraftCache.userId, userId)
+    )
+  );
+}
+async function cleanupOldDrafts(daysOld = 30) {
+  const cutoffDate = /* @__PURE__ */ new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+  return deleteMany2(
+    cmsDraftCache,
+    lt(cmsDraftCache.updatedAt, cutoffDate)
+  );
+}
+var cmsDraftCacheRepository = {
+  findByUser,
+  upsert: upsert2,
+  findAllByUser,
+  deleteByUser,
+  cleanupOldDrafts
+};
+
+// src/server/repositories/cms-published-cache.repository.ts
+import { findOne as findOne4, findMany as findMany4, deleteOne as deleteOne3, deleteMany as deleteMany3, upsert as upsertHelper2 } from "@spfn/core/db";
+import { eq as eq3, and as and3, sql } from "drizzle-orm";
+async function findBySection2(section, locale = "ko") {
+  return findOne4(
+    cmsPublishedCache,
+    and3(
+      eq3(cmsPublishedCache.section, section),
+      eq3(cmsPublishedCache.locale, locale)
+    )
+  );
+}
+async function upsert3(data) {
+  return upsertHelper2(cmsPublishedCache, data, {
+    target: [cmsPublishedCache.section, cmsPublishedCache.locale],
+    set: {
+      content: data.content,
+      publishedAt: data.publishedAt,
+      publishedBy: data.publishedBy,
+      version: sql`${cmsPublishedCache.version} + 1`
+      // 버전 증가로 클라이언트 캐시 무효화
+    }
+  });
+}
+async function findAllLanguages(section) {
+  return findMany4(cmsPublishedCache, {
+    where: eq3(cmsPublishedCache.section, section)
+  });
+}
+async function deleteBySection(section, locale) {
+  if (locale) {
+    await deleteOne3(
+      cmsPublishedCache,
+      and3(
+        eq3(cmsPublishedCache.section, section),
+        eq3(cmsPublishedCache.locale, locale)
+      )
+    );
+  } else {
+    await deleteMany3(
+      cmsPublishedCache,
+      eq3(cmsPublishedCache.section, section)
+    );
+  }
+}
+var cmsPublishedCacheRepository = {
+  findBySection: findBySection2,
+  upsert: upsert3,
+  findAllLanguages,
+  deleteBySection
+};
+
+// src/server/helpers/sync.ts
+async function syncAll(sections, options = {}) {
+  const results = [];
+  for (const definition of sections) {
+    const result = await syncSection(definition, options);
+    results.push(result);
+  }
+  return results;
+}
+function loadLabelsFromJson(labelsDir) {
+  const sections = [];
+  if (!existsSync(labelsDir)) {
+    console.warn(`[CMS] Labels directory not found: ${labelsDir}`);
+    console.warn(`[CMS] Expected directory structure:`);
+    console.warn(`[CMS]   ${labelsDir}/`);
+    console.warn(`[CMS]     \u251C\u2500\u2500 common/          # Section directory`);
+    console.warn(`[CMS]     \u2502   \u251C\u2500\u2500 messages.json`);
+    console.warn(`[CMS]     \u2502   \u2514\u2500\u2500 errors.json`);
+    console.warn(`[CMS]     \u2514\u2500\u2500 home/            # Section directory`);
+    console.warn(`[CMS]         \u2514\u2500\u2500 hero.json`);
+    return sections;
+  }
+  try {
+    const entries = readdirSync(labelsDir);
+    if (entries.length === 0) {
+      console.warn(`[CMS] Labels directory is empty: ${labelsDir}`);
+      console.warn(`[CMS] Create section directories with JSON files inside`);
+      return sections;
+    }
+    const jsonFiles = entries.filter((e) => extname(e) === ".json");
+    if (jsonFiles.length > 0) {
+      console.warn(`[CMS] Found JSON files directly in ${labelsDir}:`);
+      jsonFiles.forEach((f) => console.warn(`[CMS]   - ${f} (will be ignored)`));
+      console.warn(`[CMS] JSON files should be inside section directories`);
+      console.warn(`[CMS] Example: Move ${jsonFiles[0]} to ${labelsDir}/${basename(jsonFiles[0], ".json")}/${jsonFiles[0]}`);
+    }
+    for (const entry of entries) {
+      const sectionPath = join(labelsDir, entry);
+      const stat = statSync(sectionPath);
+      if (stat.isDirectory()) {
+        const sectionName = entry;
+        const labels = loadSectionLabels(sectionPath);
+        if (Object.keys(labels).length > 0) {
+          sections.push({ section: sectionName, labels });
+        } else {
+          console.warn(`[CMS] Section directory "${sectionName}" has no valid JSON files`);
+        }
+      }
+    }
+    if (sections.length === 0) {
+      console.warn(`[CMS] No valid section directories found in ${labelsDir}`);
+    }
+  } catch (error) {
+    console.warn(`[CMS] Could not scan labels directory: ${labelsDir}`);
+    console.error(`[CMS] Error:`, error);
+  }
+  return sections;
+}
+function loadSectionLabels(sectionPath) {
+  const labels = {};
+  try {
+    const files = readdirSync(sectionPath);
+    for (const file of files) {
+      if (extname(file) === ".json") {
+        const filePath = join(sectionPath, file);
+        const categoryName = basename(file, ".json");
+        try {
+          const content = readFileSync(filePath, "utf-8");
+          labels[categoryName] = JSON.parse(content);
+        } catch (error) {
+          console.warn(`[CMS] Failed to parse ${filePath}`);
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`[CMS] Could not read section directory: ${sectionPath}`);
+  }
+  return labels;
+}
+async function syncSection(definition, options = {}) {
+  const {
+    dryRun = false,
+    updateExisting = false,
+    removeUnused = false,
+    verbose = false
+  } = options;
+  const { section } = definition;
+  const result = {
+    section,
+    created: 0,
+    updated: 0,
+    deleted: 0,
+    unchanged: 0,
+    errors: []
+  };
+  try {
+    const definedLabels = extractLabels(definition);
+    const definedKeys = new Set(definedLabels.map((l) => l.key));
+    const existingLabels = await cmsLabelsRepository.findBySection(section);
+    const existingMap = new Map(existingLabels.map((l) => [l.key, l]));
+    if (verbose) {
+      console.log(`
+[${section}] Found ${definedLabels.length} labels in definition`);
+      console.log(`[${section}] Found ${existingLabels.length} labels in DB`);
+    }
+    for (const label of definedLabels) {
+      const existing = existingMap.get(label.key);
+      if (!existing) {
+        if (verbose) console.log(`  [CREATE] ${label.key}`);
+        if (!dryRun) {
+          try {
+            const defaultValue = typeof label.defaultValue === "object" ? JSON.stringify(label.defaultValue) : label.defaultValue;
+            await cmsLabelsRepository.create({
+              section,
+              key: label.key,
+              type: label.type || "text",
+              // 라벨 타입 (기본값: 'text')
+              defaultValue,
+              description: label.description
+            });
+          } catch (error) {
+            result.errors.push({
+              key: label.key,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            continue;
+          }
+        }
+        result.created++;
+      } else if (updateExisting) {
+        const newDefaultValue = typeof label.defaultValue === "object" ? JSON.stringify(label.defaultValue) : label.defaultValue;
+        const hasChanged = existing.defaultValue !== newDefaultValue;
+        if (hasChanged) {
+          if (verbose) {
+            console.log(`  [UPDATE] ${label.key}`);
+            console.log(`    Old: "${existing.defaultValue}"`);
+            console.log(`    New: "${newDefaultValue}"`);
+          }
+          if (!dryRun) {
+            try {
+              await cmsLabelsRepository.updateById(existing.id, {
+                defaultValue: newDefaultValue,
+                description: label.description
+              });
+            } catch (error) {
+              result.errors.push({
+                key: label.key,
+                error: error instanceof Error ? error.message : String(error)
+              });
+              continue;
+            }
+          }
+          result.updated++;
+        } else {
+          result.unchanged++;
+        }
+      } else {
+        result.unchanged++;
+      }
+    }
+    if (removeUnused) {
+      for (const existing of existingLabels) {
+        if (!definedKeys.has(existing.key)) {
+          if (verbose) console.log(`  [DELETE] ${existing.key}`);
+          if (!dryRun) {
+            try {
+              await cmsLabelsRepository.deleteById(existing.id);
+            } catch (error) {
+              result.errors.push({
+                key: existing.key,
+                error: error instanceof Error ? error.message : String(error)
+              });
+              continue;
+            }
+          }
+          result.deleted++;
+        }
+      }
+    }
+    if (!dryRun && (result.created > 0 || result.updated > 0 || result.deleted > 0)) {
+      if (verbose) console.log(`  [CACHE] Updating published cache for section: ${section}`);
+      await updatePublishedCache(section);
+    }
+  } catch (error) {
+    result.errors.push({
+      key: "__section__",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  return result;
+}
+async function updatePublishedCache(section) {
+  const labels = await cmsLabelsRepository.findBySection(section);
+  const localesSet = /* @__PURE__ */ new Set();
+  const labelsByLocale = {};
+  labels.forEach((label) => {
+    try {
+      const parsed = JSON.parse(label.defaultValue || "{}");
+      if (typeof parsed === "object" && !Array.isArray(parsed)) {
+        Object.keys(parsed).forEach((locale) => localesSet.add(locale));
+        Object.entries(parsed).forEach(([locale, value]) => {
+          if (!labelsByLocale[locale]) labelsByLocale[locale] = {};
+          labelsByLocale[locale][label.key] = value;
+        });
+      } else {
+        if (!labelsByLocale.ko) labelsByLocale.ko = {};
+        labelsByLocale.ko[label.key] = label.defaultValue;
+        localesSet.add("ko");
+      }
+    } catch {
+      if (!labelsByLocale.ko) labelsByLocale.ko = {};
+      labelsByLocale.ko[label.key] = label.defaultValue;
+      localesSet.add("ko");
+    }
+  });
+  const timestamp7 = /* @__PURE__ */ new Date();
+  for (const locale of localesSet) {
+    await cmsPublishedCacheRepository.upsert({
+      section,
+      locale,
+      content: labelsByLocale[locale] || {},
+      publishedAt: timestamp7,
+      publishedBy: "system"
+    });
+  }
+}
+async function initLabelSync(options = {}) {
+  const isDevelopment = process.env.NODE_ENV === "development";
+  const verbose = options.verbose ?? isDevelopment;
+  const labelsDir = options.labelsDir ?? "src/cms/labels";
+  if (verbose) {
+    console.log("\n\u{1F504} Initializing label sync...\n");
+  }
+  const sections = loadLabelsFromJson(labelsDir);
+  if (sections.length === 0) {
+    if (verbose) {
+      console.log("\u26A0\uFE0F  No labels found in", labelsDir);
+      console.log("");
+    }
+    return;
+  }
+  const results = await syncAll(sections, {
+    updateExisting: true,
+    // 🔄 항상 업데이트 (프로덕션 포함)
+    ...options,
+    verbose
+  });
+  const totalCreated = results.reduce((sum, r) => sum + r.created, 0);
+  const totalUpdated = results.reduce((sum, r) => sum + r.updated, 0);
+  const totalUnchanged = results.reduce((sum, r) => sum + r.unchanged, 0);
+  const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
+  if (verbose) {
+    console.log("\u2705 Label sync completed\n");
+    console.log(`   Sections: ${results.length}`);
+    console.log(`   Created:  ${totalCreated}`);
+    console.log(`   Updated:  ${totalUpdated}`);
+    console.log(`   Unchanged: ${totalUnchanged}`);
+    if (totalErrors > 0) {
+      console.log(`   Errors:   ${totalErrors}
+`);
+    } else {
+      console.log("");
+    }
+  }
+  if (totalErrors > 0) {
+    results.forEach((result) => {
+      result.errors.forEach((error) => {
+        console.error(`[${result.section}] ${error.key}: ${error.error}`);
+      });
+    });
+  }
+}
+
+// src/server/generators/label-sync-generator.ts
+import { logger } from "@spfn/core/logger";
+import { join as join2, relative, extname as extname2 } from "path";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+
+// src/lib/constants/index.ts
+var DEFAULT_LABELS_DIR = "src/lib/labels";
+
+// src/server/generators/label-sync-generator.ts
+var syncLogger = logger.child("label-sync");
+function createLabelSyncGenerator(config = {}) {
+  const labelsDir = config.labelsDir ?? DEFAULT_LABELS_DIR;
+  const runOn = config.runOn ?? ["watch", "manual", "build"];
+  return {
+    name: "label-sync",
+    watchPatterns: [`${labelsDir}/**/*.json`],
+    runOn,
+    async generate(options) {
+      const labelsPath = join2(options.cwd, labelsDir);
+      if (!existsSync2(labelsPath)) {
+        if (options.debug) {
+          syncLogger.warn(`Labels directory not found: ${labelsPath}`);
+        }
+        return;
+      }
+      try {
+        const changedFile = options.trigger?.changedFile;
+        if (changedFile && changedFile.event === "change") {
+          const success = await attemptIncrementalSync({
+            cwd: options.cwd,
+            labelsPath,
+            changedFilePath: changedFile.path,
+            debug: options.debug
+          });
+          if (success) {
+            if (options.debug) {
+              syncLogger.info("Incremental sync successful");
+            }
+            return;
+          }
+          if (options.debug) {
+            syncLogger.info("Incremental sync failed, doing full sync");
+          }
+        }
+        if (options.debug) {
+          syncLogger.info("Starting full label sync...");
+        }
+        const sections = loadLabelsFromJson(labelsPath);
+        if (sections.length === 0) {
+          syncLogger.warn(`No labels found in ${labelsPath}`);
+          return;
+        }
+        syncLogger.info(`Found ${sections.length} sections`);
+        const results = await syncAll(sections, {
+          verbose: options.debug ?? false,
+          updateExisting: true
+        });
+        const totalCreated = results.reduce((sum, r) => sum + r.created, 0);
+        const totalUpdated = results.reduce((sum, r) => sum + r.updated, 0);
+        const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
+        if (options.debug || totalCreated > 0 || totalUpdated > 0) {
+          syncLogger.info("Label sync completed", {
+            sections: results.length,
+            created: totalCreated,
+            updated: totalUpdated,
+            errors: totalErrors
+          });
+        }
+        if (totalErrors > 0) {
+          results.forEach((result) => {
+            result.errors.forEach((error) => {
+              syncLogger.error(`[${result.section}] ${error.key}: ${error.error}`);
+            });
+          });
+        }
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        syncLogger.error("Label sync failed", err);
+        throw err;
+      }
+    }
+  };
+}
+async function attemptIncrementalSync(options) {
+  const { cwd, labelsPath, changedFilePath, debug } = options;
+  try {
+    const fullPath = join2(cwd, changedFilePath);
+    if (!existsSync2(fullPath)) {
+      return false;
+    }
+    const relativePath = relative(labelsPath, fullPath);
+    const parts = relativePath.split("/");
+    if (parts.length < 2) {
+      return false;
+    }
+    const sectionName = parts[0];
+    if (debug) {
+      syncLogger.info("Attempting incremental sync", {
+        section: sectionName,
+        file: changedFilePath
+      });
+    }
+    const sectionPath = join2(labelsPath, sectionName);
+    const labels = loadSectionLabels2(sectionPath);
+    if (Object.keys(labels).length === 0) {
+      if (debug) {
+        syncLogger.warn("Section has no valid labels");
+      }
+      return false;
+    }
+    const result = await syncSection(
+      { section: sectionName, labels },
+      { verbose: debug, updateExisting: true }
+    );
+    if (debug || result.created > 0 || result.updated > 0) {
+      syncLogger.info(`[${sectionName}] Incremental sync completed`, {
+        created: result.created,
+        updated: result.updated,
+        unchanged: result.unchanged,
+        errors: result.errors.length
+      });
+    }
+    if (result.errors.length > 0) {
+      result.errors.forEach((error) => {
+        syncLogger.error(`[${sectionName}] ${error.key}: ${error.error}`);
+      });
+    }
+    return true;
+  } catch (error) {
+    if (debug) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      syncLogger.warn("Incremental sync failed", err);
+    }
+    return false;
+  }
+}
+function loadSectionLabels2(sectionPath) {
+  const labels = {};
+  if (!existsSync2(sectionPath)) {
+    return labels;
+  }
+  try {
+    const entries = readdirSync2(sectionPath);
+    for (const entry of entries) {
+      const filePath = join2(sectionPath, entry);
+      const stat = statSync2(filePath);
+      if (stat.isFile() && extname2(entry) === ".json") {
+        try {
+          const content = readFileSync2(filePath, "utf-8");
+          const data = JSON.parse(content);
+          if (typeof data === "object" && data !== null) {
+            Object.assign(labels, data);
+          }
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          syncLogger.warn(`Failed to parse ${filePath}`, err);
+        }
+      }
+    }
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    syncLogger.warn(`Failed to read section ${sectionPath}`, err);
+  }
+  return labels;
+}
+
 // src/server.ts
-function replaceVariables(text, replace) {
-  return text.replace(/\{(\w+)}/g, (match, key) => {
+function replaceVariables(text7, replace) {
+  return text7.replace(/\{(\w+)}/g, (match, key) => {
     const value = replace[key];
     return value !== void 0 ? String(value) : match;
   });
@@ -269,7 +1718,31 @@ var getSections = cache(async (sections, locale) => {
   }
 });
 export {
+  LOCALE_COOKIE_KEY,
+  LOCALE_INFO_MAP,
+  cmsAuditLogs,
+  cmsDraftCache,
+  cmsDraftCacheRepository,
+  cmsLabelValues,
+  cmsLabelValuesRepository,
+  cmsLabelVersions,
+  cmsLabels,
+  cmsLabelsRepository,
+  cmsPublishedCache,
+  cmsPublishedCacheRepository,
+  createLabelSyncGenerator,
+  extractLabels,
+  flattenLabels,
+  getDialCode,
+  getFlag,
+  getLocaleInfo,
   getSection,
-  getSections
+  getSections,
+  getSupportedLocales,
+  initLabelSync,
+  isRTL,
+  loadLabelsFromJson,
+  syncAll,
+  syncSection
 };
 //# sourceMappingURL=server.js.map