@bstage-sdk/core 0.8.0 → 0.8.2

package/dist/index.cjs

@@ -0,0 +1,932 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ADMIN_EVENT_CATALOG: () => ADMIN_EVENT_CATALOG,
+  BstageClient: () => BstageClient,
+  DEFAULT_LANGUAGE: () => DEFAULT_LANGUAGE,
+  HttpClient: () => HttpClient,
+  HttpError: () => HttpError,
+  HttpTimeoutError: () => HttpTimeoutError,
+  LANGUAGES: () => LANGUAGES,
+  PlatformBridge: () => PlatformBridge,
+  SLOT_CATALOG: () => SLOT_CATALOG,
+  SLOT_CATALOG_V2: () => SLOT_CATALOG_V2,
+  VERSION: () => VERSION,
+  __resetElementRegistry__: () => __resetElementRegistry__,
+  announceElementName: () => announceElementName,
+  configureBstageI18n: () => configureBstageI18n,
+  createWebComponent: () => createWebComponent,
+  dirNameToSlotId: () => dirNameToSlotId,
+  fetchTranslations: () => fetchTranslations,
+  getAdminEventsByDomain: () => getAdminEventsByDomain,
+  getSlotsByTarget: () => getSlotsByTarget,
+  getSlotsByTargetV2: () => getSlotsByTargetV2,
+  interpolateTranslation: () => interpolateTranslation,
+  isSlotIdV2: () => isSlotIdV2,
+  lookupElementName: () => lookupElementName,
+  normalizeLanguage: () => normalizeLanguage,
+  observeLocale: () => observeLocale,
+  parseRichText: () => parseRichText,
+  pickTranslation: () => pickTranslation,
+  readLocale: () => readLocale,
+  resolveTranslationChain: () => resolveTranslationChain,
+  slotIdToDirName: () => slotIdToDirName
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/http/HttpClient.ts
+var HttpClient = class {
+  constructor(config) {
+    this.requestInterceptors = [];
+    this.responseInterceptors = [];
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.defaultHeaders = config.headers ?? {};
+    this.defaultTimeout = config.timeout ?? 3e4;
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  addRequestInterceptor(interceptor) {
+    this.requestInterceptors.push(interceptor);
+  }
+  addResponseInterceptor(interceptor) {
+    this.responseInterceptors.push(interceptor);
+  }
+  async request(config) {
+    let resolvedConfig = { ...config };
+    for (const interceptor of this.requestInterceptors) {
+      resolvedConfig = await interceptor(resolvedConfig);
+    }
+    const url = this.buildUrl(resolvedConfig.url, resolvedConfig.params);
+    const timeout = resolvedConfig.timeout ?? this.defaultTimeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const fetchResponse = await this.fetchFn(url, {
+        method: resolvedConfig.method,
+        headers: {
+          ...this.defaultHeaders,
+          ...resolvedConfig.headers
+        },
+        body: resolvedConfig.body != null ? JSON.stringify(resolvedConfig.body) : void 0,
+        signal: controller.signal,
+        credentials: "include"
+      });
+      const data = await this.parseResponse(fetchResponse);
+      let response = {
+        status: fetchResponse.status,
+        headers: fetchResponse.headers,
+        data
+      };
+      for (const interceptor of this.responseInterceptors) {
+        response = await interceptor(response);
+      }
+      if (!fetchResponse.ok) {
+        throw new HttpError(response);
+      }
+      return response;
+    } catch (error) {
+      if (error instanceof HttpError) throw error;
+      if (isAbortError(error)) {
+        throw new HttpTimeoutError(timeout, url);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async get(url, options) {
+    return this.request({ method: "GET", url, ...options });
+  }
+  async post(url, options) {
+    return this.request({ method: "POST", url, ...options });
+  }
+  async put(url, options) {
+    return this.request({ method: "PUT", url, ...options });
+  }
+  async patch(url, options) {
+    return this.request({ method: "PATCH", url, ...options });
+  }
+  async delete(url, options) {
+    return this.request({ method: "DELETE", url, ...options });
+  }
+  buildUrl(path, params) {
+    const full = path.startsWith("http://") || path.startsWith("https://") ? path : `${this.baseUrl}${path}`;
+    const url = new URL(full);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value === void 0) continue;
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            url.searchParams.append(key, String(item));
+          }
+        } else {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  async parseResponse(response) {
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      return response.json();
+    }
+    return response.text();
+  }
+};
+function isAbortError(error) {
+  return typeof error === "object" && error !== null && error.name === "AbortError";
+}
+var HttpError = class extends Error {
+  constructor(response) {
+    super(`HTTP ${response.status}`);
+    this.name = "HttpError";
+    this.status = response.status;
+    this.headers = response.headers;
+    this.data = response.data;
+  }
+};
+var HttpTimeoutError = class extends Error {
+  constructor(timeout, url) {
+    super(`Request timed out after ${timeout}ms: ${url}`);
+    this.name = "HttpTimeoutError";
+    this.timeout = timeout;
+    this.url = url;
+  }
+};
+
+// src/version.ts
+var VERSION = "0.8.2";
+
+// src/client/BstageClient.ts
+function resolveBaseUrl() {
+  if (typeof globalThis.location !== "undefined") {
+    return `${globalThis.location.origin}/gw`;
+  }
+  return "/gw";
+}
+function resolvePath(template, params) {
+  if (!params) return template;
+  return template.replace(/\{([^}]+)\}/g, (_, key) => {
+    const value = params[key];
+    if (value === void 0) return `{${key}}`;
+    return encodeURIComponent(String(value));
+  });
+}
+var resolveBstageFetch = (input, init) => {
+  const hook = globalThis.__bstage_fetch__;
+  return hook ? hook(input, init) : globalThis.fetch(input, init);
+};
+var APP_ID_PREFIX = "bsa_";
+var APP_KEY_PREFIX = "bsp_";
+function warnOnSwappedCredentials(appId, appKey) {
+  const appIdLooksLikeKey = typeof appId === "string" && appId.startsWith(APP_KEY_PREFIX);
+  const appKeyLooksLikeId = typeof appKey === "string" && appKey.startsWith(APP_ID_PREFIX);
+  if (!appIdLooksLikeKey && !appKeyLooksLikeId) return;
+  console.warn(
+    `[b.stage] appId\uC640 appKey\uAC00 \uC11C\uB85C \uBC14\uB010 \uAC83 \uAC19\uC2B5\uB2C8\uB2E4.
+  appId\uB294 "${APP_ID_PREFIX}", appKey\uB294 "${APP_KEY_PREFIX}"\uB85C \uC2DC\uC791\uD574\uC57C \uD569\uB2C8\uB2E4.
+  \uD30C\uD2B8\uB108 \uCF58\uC194\uC5D0\uC11C \uBC1C\uAE09\uBC1B\uC740 \uAC12\uC744 \uB2E4\uC2DC \uD655\uC778\uD574 \uC8FC\uC138\uC694.`
+  );
+}
+function resolveAppKey(config) {
+  return config.appKey || config.appSecret || void 0;
+}
+function warnOnMissingAppKey(appKey) {
+  if (appKey !== void 0) return;
+  console.warn(
+    `[b.stage] appKey\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 X-BSTAGE-APP-KEY \uD5E4\uB354 \uC5C6\uC774 \uD638\uCD9C\uB418\uC5B4 API\uAC00 401\uC744 \uB0C5\uB2C8\uB2E4.
+  .env\uC758 VITE_BSTAGE_APP_KEY(\uD30C\uD2B8\uB108 \uCF58\uC194\uC758 APP KEY)\uB97C \uD655\uC778\uD574 \uC8FC\uC138\uC694.`
+  );
+}
+var BstageClient = class {
+  constructor(config) {
+    const appKey = resolveAppKey(config);
+    warnOnMissingAppKey(appKey);
+    warnOnSwappedCredentials(config.appId, appKey);
+    const fetchFn = config.fetch ?? resolveBstageFetch;
+    this.http = new HttpClient({
+      baseUrl: config.baseUrl ?? resolveBaseUrl(),
+      timeout: config.timeout,
+      fetch: fetchFn,
+      headers: {
+        "Content-Type": "application/json",
+        "X-BSTAGE-APP-ID": config.appId,
+        // 값이 없으면(UI 전용 템플릿의 빈 .env) 헤더 자체를 빼서 "undefined" 문자열이 실리지 않게 한다.
+        ...appKey !== void 0 ? { "X-BSTAGE-APP-KEY": appKey } : {},
+        "X-BSTAGE-TENANT-ID": config.tenantId,
+        // 어느 SDK(core) 버전이 호출하는지 게이트웨이 로그에서 볼 수 있게. 값은 버전 문자열만(패키지 이름 없음).
+        "x-bmf-sdk-version": VERSION
+      }
+    });
+  }
+  // ── GET ──────────────────────────────────────────────────────────────
+  get(url, options) {
+    const { path, ...rest } = options ?? {};
+    return this.http.get(resolvePath(url, path), rest);
+  }
+  // ── POST ─────────────────────────────────────────────────────────────
+  post(url, options) {
+    const { path, ...rest } = options ?? {};
+    return this.http.post(resolvePath(url, path), rest);
+  }
+  // ── PUT ──────────────────────────────────────────────────────────────
+  put(url, options) {
+    const { path, ...rest } = options ?? {};
+    return this.http.put(resolvePath(url, path), rest);
+  }
+  // ── PATCH ────────────────────────────────────────────────────────────
+  patch(url, options) {
+    const { path, ...rest } = options ?? {};
+    return this.http.patch(resolvePath(url, path), rest);
+  }
+  // ── DELETE ───────────────────────────────────────────────────────────
+  delete(url, options) {
+    const { path, ...rest } = options ?? {};
+    return this.http.delete(resolvePath(url, path), rest);
+  }
+};
+
+// src/i18n.ts
+var LANGUAGES = ["ko", "en", "ja", "zh-CN", "zh-TW", "es", "vi"];
+var DEFAULT_LANGUAGE = "ko";
+var LANGUAGE_COOKIE = {
+  user: "bmf_bstage_lang",
+  admin: "bmf_mybstage_locale"
+};
+var LANGUAGE_LOOKUP = new Map(
+  LANGUAGES.map((code) => [code.toLowerCase(), code])
+);
+function normalizeLanguage(value) {
+  if (!value) return void 0;
+  return LANGUAGE_LOOKUP.get(value.trim().toLowerCase());
+}
+function readLanguageCookie(target) {
+  if (typeof document === "undefined" || !document.cookie) return void 0;
+  const cookieName = LANGUAGE_COOKIE[target];
+  for (const part of document.cookie.split(";")) {
+    const [name, ...rest] = part.split("=");
+    if (name?.trim() === cookieName) {
+      return normalizeLanguage(decodeURIComponent(rest.join("=")));
+    }
+  }
+  return void 0;
+}
+function readLocale(target = "user") {
+  if (typeof document === "undefined") return DEFAULT_LANGUAGE;
+  const htmlLang = normalizeLanguage(document.documentElement.lang);
+  if (target === "admin") {
+    return readLanguageCookie("admin") ?? htmlLang ?? DEFAULT_LANGUAGE;
+  }
+  return htmlLang ?? readLanguageCookie("user") ?? DEFAULT_LANGUAGE;
+}
+function observeLocale(onChange, target = "user") {
+  if (typeof document === "undefined" || typeof MutationObserver === "undefined") {
+    return () => {
+    };
+  }
+  let current = readLocale(target);
+  const observer = new MutationObserver(() => {
+    const next = readLocale(target);
+    if (next !== current) {
+      current = next;
+      onChange(next);
+    }
+  });
+  observer.observe(document.documentElement, { attributes: true, attributeFilter: ["lang"] });
+  return () => observer.disconnect();
+}
+var TRANSLATION_ORIGIN = "https://cdn.static.bstage.in";
+var TRANSLATION_BASE_KEY = "static/i18n";
+var TRANSLATION_BUCKET_PREFIX = "cdn.bstage.in/";
+var DEFAULT_TIER = "inhouse";
+var LATEST_TTL_MS = 5 * 60 * 1e3;
+var i18nConfig = {};
+function configureBstageI18n(config) {
+  i18nConfig = { ...i18nConfig, ...config };
+}
+var PHASES = ["dev", "qa", "real", "real-canary", "sandbox"];
+function normalizePhase(value) {
+  return PHASES.find((p) => p === value);
+}
+function resolvePhase() {
+  const fromConfig = normalizePhase(i18nConfig.phase);
+  if (fromConfig) return fromConfig;
+  const injected = normalizePhase(
+    globalThis.__bstage_i18n_phase__
+  );
+  if (injected) return injected;
+  const host = typeof location === "undefined" ? "" : location.hostname;
+  if (host.includes(".dev.")) return "dev";
+  if (host.includes(".qa.")) return "qa";
+  if (host.includes("sandstage.in")) return "sandbox";
+  return "real";
+}
+function resolveSource(system) {
+  return {
+    origin: i18nConfig.origin ?? TRANSLATION_ORIGIN,
+    phase: resolvePhase(),
+    system: system ?? i18nConfig.system ?? "user",
+    tier: i18nConfig.tier ?? DEFAULT_TIER
+  };
+}
+function sourceKey(source) {
+  return `${source.origin}|${source.phase}|${source.system}|${source.tier}`;
+}
+function latestUrl(source) {
+  const segments = [TRANSLATION_BASE_KEY, source.phase, source.system];
+  if (source.tier !== DEFAULT_TIER) segments.push(source.tier);
+  return `${source.origin}/${segments.join("/")}/latest.json?date=${cacheStamp(/* @__PURE__ */ new Date())}`;
+}
+function cacheStamp(now) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const date = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${pad(now.getHours())}`;
+  const min = now.getMinutes();
+  return `${date}-${pad(min - min % 5)}`;
+}
+var latestCache = /* @__PURE__ */ new Map();
+var translationCache = /* @__PURE__ */ new Map();
+function resolveFetch() {
+  const fn = i18nConfig.fetch ?? globalThis.fetch;
+  return typeof fn === "function" ? fn : void 0;
+}
+var TRANSLATION_CACHE_NAME = "bstage-i18n-v1";
+async function openTranslationCache() {
+  try {
+    if (typeof caches === "undefined") return void 0;
+    return await caches.open(TRANSLATION_CACHE_NAME);
+  } catch {
+    return void 0;
+  }
+}
+async function fetchJsonWithCache(url, cacheKey, fetchFn, label) {
+  const cache = await openTranslationCache();
+  try {
+    const res = await fetchFn(url);
+    if (!res.ok) throw new Error(`${label}: HTTP ${res.status}`);
+    if (cache) {
+      await cache.put(cacheKey, res.clone()).catch(() => {
+      });
+    }
+    return await res.json();
+  } catch (err) {
+    const hit = await cache?.match(cacheKey).catch(() => void 0);
+    if (hit) return await hit.json();
+    throw err;
+  }
+}
+async function pruneOldVersions(source, keepBase) {
+  const cache = await openTranslationCache();
+  if (!cache) return;
+  const prefix = `${source.origin}/${TRANSLATION_BASE_KEY}/${source.phase}/${source.system}/`;
+  try {
+    const keys = await cache.keys();
+    await Promise.all(
+      keys.map(async (req) => {
+        if (!req.url.startsWith(prefix)) return;
+        if (req.url.endsWith("latest.json")) return;
+        if (req.url.startsWith(keepBase)) return;
+        await cache.delete(req).catch(() => {
+        });
+      })
+    );
+  } catch {
+  }
+}
+function fetchVersionBase(source, fetchFn) {
+  const key = sourceKey(source);
+  const cached = latestCache.get(key);
+  if (cached && Date.now() - cached.at < LATEST_TTL_MS) return cached.promise;
+  const url = latestUrl(source);
+  const promise = fetchJsonWithCache(
+    url,
+    url.split("?")[0],
+    fetchFn,
+    `i18n latest ${source.phase}/${source.system}`
+  ).then((latest) => {
+    if (!latest?.cdnPath) throw new Error("i18n latest: cdnPath \uC5C6\uC74C");
+    const base = `${source.origin}/${latest.cdnPath.replace(TRANSLATION_BUCKET_PREFIX, "")}`;
+    void pruneOldVersions(source, base);
+    return base;
+  }).catch((err) => {
+    latestCache.delete(key);
+    throw err;
+  });
+  latestCache.set(key, { at: Date.now(), promise });
+  return promise;
+}
+function fetchTranslations(locale, system) {
+  const source = resolveSource(system);
+  const key = `${sourceKey(source)}|${locale}`;
+  const cached = translationCache.get(key);
+  if (cached) return cached;
+  const fetchFn = resolveFetch();
+  if (!fetchFn) return Promise.reject(new Error("fetch unavailable"));
+  const promise = fetchVersionBase(source, fetchFn).then((base) => {
+    const url = `${base}/${locale}/translation.json`;
+    return fetchJsonWithCache(url, url, fetchFn, `translations ${locale}`);
+  }).catch((err) => {
+    translationCache.delete(key);
+    throw err;
+  });
+  translationCache.set(key, promise);
+  return promise;
+}
+var DEFAULT_FALLBACK_CHAIN = ["en", "ko"];
+function resolveTranslationChain(current) {
+  const tail = i18nConfig.fallbackChain ?? DEFAULT_FALLBACK_CHAIN;
+  return [current, ...tail].filter((locale, i, all) => all.indexOf(locale) === i);
+}
+function pickTranslation(dicts, key) {
+  for (const dict of dicts) {
+    const value = dict[key];
+    if (typeof value === "string" && value.trim() !== "") return value;
+  }
+  return void 0;
+}
+var RICH_TAG_RE = /<(\d+)>([\s\S]*?)<\/\1>/g;
+function parseRichText(template, params) {
+  const tokens = [];
+  let cursor = 0;
+  for (const match of template.matchAll(RICH_TAG_RE)) {
+    const at = match.index ?? 0;
+    if (at > cursor) {
+      tokens.push({
+        type: "text",
+        value: interpolateTranslation(template.slice(cursor, at), params)
+      });
+    }
+    tokens.push({
+      type: "tag",
+      index: Number(match[1]),
+      value: interpolateTranslation(match[2], params)
+    });
+    cursor = at + match[0].length;
+  }
+  if (cursor < template.length) {
+    tokens.push({ type: "text", value: interpolateTranslation(template.slice(cursor), params) });
+  }
+  return tokens;
+}
+function interpolateTranslation(template, params) {
+  if (!params) return template;
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    const value = params[key];
+    return value === void 0 ? `{{${key}}}` : String(value);
+  });
+}
+
+// src/core/adminEvents.ts
+var ADMIN_EVENT_CATALOG = [
+  {
+    type: "ticket.create.after",
+    domain: "ticket",
+    description: "\uD2F0\uCF13 \uC0DD\uC131 \uC644\uB8CC \uD6C4 \uBC1C\uD589. \uCEE4\uC2A4\uD140 UI\uAC00 \uD6C4\uC18D \uCC98\uB9AC(QR \uC800\uC7A5 \uB4F1)\uB97C \uC218\uD589\uD560 \uC218 \uC788\uB2E4."
+  }
+];
+function getAdminEventsByDomain(domain) {
+  return ADMIN_EVENT_CATALOG.filter((e) => e.domain === domain);
+}
+
+// src/core/slotCatalog.ts
+var SLOT_CATALOG = [
+  {
+    key: "contents.home.contents.before",
+    target: "user",
+    page: "contents.home",
+    section: "contents",
+    position: "before",
+    description: "\uCF58\uD150\uCE20 \uD648 \u2014 \uCF58\uD150\uCE20 \uC139\uC158 \uC704 (Curation/Tags/Show \uC544\uB798)"
+  },
+  {
+    key: "contents.home.contents.after",
+    target: "user",
+    page: "contents.home",
+    section: "contents",
+    position: "after",
+    description: "\uCF58\uD150\uCE20 \uD648 \u2014 \uCF58\uD150\uCE20 \uC139\uC158 \uC544\uB798 (Footer \uC704)"
+  },
+  {
+    key: "products.digital-ticket.form-additional.after",
+    target: "admin",
+    page: "products.digital-ticket",
+    section: "form-additional",
+    position: "after",
+    description: "\uB514\uC9C0\uD138 \uD2F0\uCF13 \uC0DD\uC131/\uC218\uC815 \u2014 \uCD94\uAC00 \uC124\uC815 \uC2A4\uD15D \uC544\uB798"
+  },
+  {
+    key: "shop.order-item.ticket.after",
+    target: "user",
+    page: "shop.order-item",
+    section: "ticket",
+    position: "after",
+    description: "\uC8FC\uBB38 \uC544\uC774\uD15C \u2014 \uB514\uC9C0\uD138 \uD2F0\uCF13 \uC815\uBCF4 \uC544\uB798"
+  },
+  // 어드민 메뉴 슬롯 — 서브메뉴
+  {
+    key: "admin.nav.my-stage.menu.after",
+    target: "admin",
+    page: "admin.nav",
+    section: "my-stage",
+    position: "after",
+    description: "\uB0B4 \uD648\uD398\uC774\uC9C0 \uC11C\uBE0C\uBA54\uB274 \uD558\uB2E8"
+  },
+  {
+    key: "admin.nav.contents.menu.after",
+    target: "admin",
+    page: "admin.nav",
+    section: "contents",
+    position: "after",
+    description: "\uCF58\uD150\uCE20 \uC11C\uBE0C\uBA54\uB274 \uD558\uB2E8"
+  },
+  {
+    key: "admin.nav.products.menu.after",
+    target: "admin",
+    page: "admin.nav",
+    section: "products",
+    position: "after",
+    description: "\uC0C1\uD488 \uC11C\uBE0C\uBA54\uB274 \uD558\uB2E8"
+  },
+  {
+    key: "admin.nav.orders.menu.after",
+    target: "admin",
+    page: "admin.nav",
+    section: "orders",
+    position: "after",
+    description: "\uC8FC\uBB38 \uC11C\uBE0C\uBA54\uB274 \uD558\uB2E8"
+  },
+  {
+    key: "admin.nav.settlement.menu.after",
+    target: "admin",
+    page: "admin.nav",
+    section: "settlement",
+    position: "after",
+    description: "\uC815\uC0B0 \uC11C\uBE0C\uBA54\uB274 \uD558\uB2E8"
+  },
+  {
+    key: "admin.nav.operation.menu.after",
+    target: "admin",
+    page: "admin.nav",
+    section: "operation",
+    position: "after",
+    description: "\uD68C\uC6D0 \uC11C\uBE0C\uBA54\uB274 \uD558\uB2E8"
+  },
+  {
+    key: "admin.nav.settings.menu.after",
+    target: "admin",
+    page: "admin.nav",
+    section: "settings",
+    position: "after",
+    description: "\uC124\uC815 \uC11C\uBE0C\uBA54\uB274 \uD558\uB2E8"
+  },
+  // 어드민 메뉴 슬롯 — 대메뉴
+  {
+    key: "admin.nav.menu.after",
+    target: "admin",
+    page: "admin.nav",
+    section: "menu",
+    position: "after",
+    description: "\uB300\uBA54\uB274 \uBAA9\uB85D \uD558\uB2E8 (\uC0C8 \uBA54\uB274 \uADF8\uB8F9)"
+  }
+];
+function getSlotsByTarget(target) {
+  return SLOT_CATALOG.filter((s) => s.target === target);
+}
+
+// src/core/slotCatalogV2.ts
+var SLOT_CATALOG_V2 = {
+  // 어드민 — 디지털 티켓 상세 (PoC 한계가 알려진 영역. 결정-016)
+  "admin.digital-ticket-detail.form:after": {
+    description: "\uB514\uC9C0\uD138 \uD2F0\uCF13 \uC0C1\uC138 \uBCF8\uBB38 \uC544\uB798",
+    context: {
+      ticket: { type: "DigitalTicket", required: true }
+    }
+  },
+  // 어드민 — 콘텐츠 목록 PageTitleContainer 아래
+  "admin.contents-list.list:before": {
+    description: "\uCF58\uD150\uCE20 \uBAA9\uB85D \u2014 \uBAA9\uB85D \uC704",
+    context: {}
+  },
+  // 어드민 — 커뮤니티 보드 목록 PageTitleContainer 아래
+  "admin.community-board-list.list:before": {
+    description: "\uCEE4\uBBA4\uB2C8\uD2F0 \uBCF4\uB4DC \uBAA9\uB85D \u2014 \uBAA9\uB85D \uC704",
+    context: {}
+  },
+  // 유저 — 콘텐츠 홈 (결정-018에 1차 명시. curation은 신설, contents-section은 옛 contents.home.contents.before/after 이전)
+  "user.contents-home.curation:after": {
+    description: "\uCF58\uD150\uCE20 \uD648 \u2014 \uD050\uB808\uC774\uC158 \uC139\uC158 \uC544\uB798",
+    context: {}
+  },
+  "user.contents-home.contents-section:before": {
+    description: "\uCF58\uD150\uCE20 \uD648 \u2014 \uCF58\uD150\uCE20 \uC139\uC158 \uBB36\uC74C \uC704",
+    context: {}
+  },
+  "user.contents-home.contents-section:after": {
+    description: "\uCF58\uD150\uCE20 \uD648 \u2014 \uCF58\uD150\uCE20 \uC139\uC158 \uBB36\uC74C \uC544\uB798",
+    context: {}
+  },
+  // 유저 — 콘텐츠 상세 (포스트·미디어 두 렌더러가 같은 자리 키를 공유)
+  "user.contents-detail.body:before": {
+    description: "\uCF58\uD150\uCE20 \uC0C1\uC138 \u2014 \uBCF8\uBB38 \uC704",
+    context: {
+      content: { type: "Content", required: true }
+    }
+  },
+  "user.contents-detail.body:after": {
+    description: "\uCF58\uD150\uCE20 \uC0C1\uC138 \u2014 \uBCF8\uBB38 \uC544\uB798",
+    context: {
+      content: { type: "Content", required: true }
+    }
+  },
+  "user.contents-detail.comments:before": {
+    description: "\uCF58\uD150\uCE20 \uC0C1\uC138 \u2014 \uB313\uAE00 \uC139\uC158 \uC704",
+    context: {
+      content: { type: "Content", required: true }
+    }
+  },
+  // 유저 — 콘텐츠 큐레이션 목록
+  // list:after는 미도입 — 페이지 끝 자리가 전역 footer 영역(user.app-footer.*)과 겹침 (결정-021과 동일 사유)
+  "user.contents-curation.list:before": {
+    description: "\uCF58\uD150\uCE20 \uD050\uB808\uC774\uC158 \uBAA9\uB85D \u2014 \uBAA9\uB85D \uC704",
+    context: {}
+  },
+  // 유저 — 콘텐츠 섹션 목록 (list:after 미도입 — 큐레이션과 동일 사유)
+  "user.contents-section.list:before": {
+    description: "\uCF58\uD150\uCE20 \uC139\uC158 \uBAA9\uB85D \u2014 \uBAA9\uB85D \uC704",
+    context: {
+      section: { type: "ContentsSectionInfo", required: true }
+    }
+  },
+  // 유저 — 스토리 홈 (feed:after 미도입 — 무한스크롤 끝 + footer 인접)
+  "user.story-home.feed:before": {
+    description: "\uC2A4\uD1A0\uB9AC \uD648 \u2014 \uD53C\uB4DC \uC601\uC5ED \uC704",
+    context: {}
+  },
+  // 유저 — 스토리 피드 상세
+  "user.story-feed-detail.post:before": {
+    description: "\uC2A4\uD1A0\uB9AC \uD53C\uB4DC \uC0C1\uC138 \u2014 \uD3EC\uC2A4\uD2B8 \uC601\uC5ED \uC704",
+    context: {
+      content: { type: "Content", required: true }
+    }
+  },
+  "user.story-feed-detail.comments:before": {
+    description: "\uC2A4\uD1A0\uB9AC \uD53C\uB4DC \uC0C1\uC138 \u2014 \uB313\uAE00 \uC139\uC158 \uC704 (\uBCF8\uBB38 \uC544\uB798)",
+    context: {
+      content: { type: "Content", required: true }
+    }
+  },
+  // 유저 — POP 홈 (단일 페이지·단일 자리 — 조건부 섹션이 많아 항상 렌더되는 구독 목록 기준)
+  "user.pop-home.list:before": {
+    description: "POP \uD648 \u2014 \uAD6C\uB3C5 \uBAA9\uB85D \uC704",
+    context: {}
+  },
+  // 유저 — 커뮤니티 보드 (커뮤니티 홈(/community)과 보드 상세가 같은 화면이라 한 키 공유)
+  "user.community-board.feed:before": {
+    description: "\uCEE4\uBBA4\uB2C8\uD2F0 \uBCF4\uB4DC \u2014 \uD53C\uB4DC \uBAA9\uB85D \uC704",
+    context: {
+      board: { type: "BoardInfo", required: true }
+    }
+  },
+  // 유저 — 커뮤니티 포스트 상세 (보드 포스트는 콘텐츠 엔티티가 아니라 Content 대신 전용 약속 사용)
+  "user.community-post-detail.post:before": {
+    description: "\uCEE4\uBBA4\uB2C8\uD2F0 \uD3EC\uC2A4\uD2B8 \uC0C1\uC138 \u2014 \uD3EC\uC2A4\uD2B8 \uC601\uC5ED \uC704",
+    context: {
+      post: { type: "BoardPostInfo", required: true }
+    }
+  },
+  "user.community-post-detail.comments:before": {
+    description: "\uCEE4\uBBA4\uB2C8\uD2F0 \uD3EC\uC2A4\uD2B8 \uC0C1\uC138 \u2014 \uB313\uAE00 \uC139\uC158 \uC704 (\uBCF8\uBB38 \uC544\uB798)",
+    context: {
+      post: { type: "BoardPostInfo", required: true }
+    }
+  },
+  // 유저 — 라운지 (메인과 다른 전용 컴포넌트라 라운지 전용 페이지 키. 멀티 인스턴스 — 매핑은 모든 라운지 공통)
+  // 라운지 커뮤니티: 홈(/lounge/[h]/community)·보드 상세가 같은 컴포넌트라 한 키 공유 (메인 community 패턴)
+  "user.lounge-community.feed:before": {
+    description: "\uB77C\uC6B4\uC9C0 \uCEE4\uBBA4\uB2C8\uD2F0 \u2014 \uD53C\uB4DC \uBAA9\uB85D \uC704",
+    context: {
+      board: { type: "BoardInfo", required: true }
+    }
+  },
+  // 라운지 콘텐츠
+  "user.lounge-contents.section:before": {
+    description: "\uB77C\uC6B4\uC9C0 \uCF58\uD150\uCE20 \u2014 \uC139\uC158 \uBB36\uC74C \uC704",
+    context: {}
+  },
+  // 라운지 스토리 (홈·/story/feed 같은 컴포넌트)
+  "user.lounge-story.feed:before": {
+    description: "\uB77C\uC6B4\uC9C0 \uC2A4\uD1A0\uB9AC \u2014 \uD53C\uB4DC \uC601\uC5ED \uC704",
+    context: {}
+  },
+  // 유저 — 샵 홈 (SectionPage 공유 → 호스트가 주입 지점으로 격리. 콘텐츠 홈 성격이라 context 없음)
+  // 고정 섹션 묶음 + 실제 footer라 콘텐츠 홈처럼 before/after 둘 다 둠 (무한스크롤 아님 — list/feed의 :after 미도입 사유 해당 없음)
+  "user.shop-home.section:before": {
+    description: "\uC0F5 \uD648 \u2014 \uC139\uC158 \uBB36\uC74C \uC704",
+    context: {}
+  },
+  "user.shop-home.section:after": {
+    description: "\uC0F5 \uD648 \u2014 \uC139\uC158 \uBB36\uC74C \uC544\uB798 (footer \uC704)",
+    context: {}
+  },
+  // 유저 — 상품 상세 (Physical·Digital·PopPass·Ticket 4개 렌더러 공통 — 컨테이너 레벨 자리)
+  "user.product-detail.detail:after": {
+    description: "\uC0C1\uD488 \uC0C1\uC138 \u2014 \uBCF8\uBB38 \uC544\uB798",
+    context: {
+      product: { type: "Product", required: true }
+    }
+  },
+  // 유저 — 마이홈 (프로필 카드와 메뉴 목록 사이. 설정성 하위 페이지는 제외)
+  "user.my-home.menu:before": {
+    description: "\uB9C8\uC774\uD648 \u2014 \uBA54\uB274 \uBAA9\uB85D \uC704 (\uD504\uB85C\uD544 \uC544\uB798)",
+    context: {}
+  }
+};
+function getSlotsByTargetV2(target) {
+  const entries = Object.entries(SLOT_CATALOG_V2);
+  return entries.filter(([id]) => id.startsWith(`${target}.`)).map(([id, entry]) => ({ id, ...entry }));
+}
+var SLOT_DIR_SEPARATOR = "--";
+function slotIdToDirName(id) {
+  return id.replace(":", SLOT_DIR_SEPARATOR);
+}
+function dirNameToSlotId(dirName) {
+  return dirName.replace(SLOT_DIR_SEPARATOR, ":");
+}
+function isSlotIdV2(value) {
+  return Object.prototype.hasOwnProperty.call(SLOT_CATALOG_V2, value);
+}
+
+// src/core/PlatformBridge.ts
+var PlatformBridge = class {
+  constructor(host) {
+    this.listeners = [];
+    this.host = host;
+  }
+  /** @internal 프레임워크 어댑터가 host 엘리먼트에 접근하기 위한 내부 메서드. */
+  getHost() {
+    return this.host;
+  }
+  /**
+   * 플랫폼으로 템플릿 이벤트를 디스패치합니다.
+   *
+   * @example
+   * bridge.emit('navigate', { path: '/lounge/123' })
+   * bridge.emit('toast', { message: 'Saved!', variant: 'success' })
+   */
+  emit(type, payload) {
+    this.host.dispatchEvent(
+      new CustomEvent(`bstage:${type}`, {
+        bubbles: true,
+        composed: true,
+        detail: payload
+      })
+    );
+  }
+  /**
+   * 호스트 엘리먼트에서 디스패치된 플랫폼 이벤트를 수신합니다.
+   * 구독 해제 함수를 반환합니다.
+   *
+   * @example
+   * const off = bridge.on('some-event', (payload) => { ... })
+   * off() // 구독 해제
+   */
+  on(type, handler) {
+    const eventType = `bstage:${type}`;
+    const listener = (e) => {
+      handler(e.detail);
+    };
+    this.host.addEventListener(eventType, listener);
+    this.listeners.push({ type: eventType, handler: listener });
+    return () => {
+      this.host.removeEventListener(eventType, listener);
+      this.listeners = this.listeners.filter((l) => l.handler !== listener);
+    };
+  }
+  /**
+   * 등록된 모든 리스너를 제거합니다. disconnectedCallback에서 호출됩니다.
+   */
+  destroy() {
+    for (const { type, handler } of this.listeners) {
+      this.host.removeEventListener(type, handler);
+    }
+    this.listeners = [];
+  }
+};
+
+// src/core/createWebComponent.ts
+function createWebComponent(createAdapter, component, options) {
+  const { shadow = true } = options;
+  class BstageElement extends HTMLElement {
+    constructor() {
+      super();
+      this._adapter = null;
+      this._bridge = null;
+      this._shadowRoot = null;
+      this._mounted = false;
+      if (shadow) {
+        this._shadowRoot = this.attachShadow({ mode: "open" });
+      }
+    }
+    connectedCallback() {
+      if (!this._mounted) {
+        this._mount();
+      }
+    }
+    disconnectedCallback() {
+      if (this._mounted) {
+        this._adapter.unmount();
+        this._bridge.destroy();
+        this._adapter = null;
+        this._bridge = null;
+        this._mounted = false;
+      }
+    }
+    _mount() {
+      const container = this._shadowRoot ?? this;
+      this._adapter = createAdapter();
+      this._bridge = new PlatformBridge(this);
+      this._adapter.mount(component, container, {}, this._bridge);
+      this._mounted = true;
+    }
+  }
+  return BstageElement;
+}
+
+// src/core/elementRegistry.ts
+var GLOBAL_KEY = "__bstage_elements__";
+function registry() {
+  const holder = globalThis;
+  return holder[GLOBAL_KEY] ?? (holder[GLOBAL_KEY] = {});
+}
+function announceElementName(tagName) {
+  if (typeof document === "undefined") return;
+  const src = document.currentScript?.src;
+  if (!src) return;
+  const map = registry();
+  if (!(src in map)) map[src] = tagName;
+}
+function lookupElementName(url) {
+  const map = registry();
+  if (url in map) return map[url];
+  try {
+    const absolute = new URL(url, typeof document !== "undefined" ? document.baseURI : void 0).href;
+    return map[absolute];
+  } catch {
+    return void 0;
+  }
+}
+function __resetElementRegistry__() {
+  ;
+  globalThis[GLOBAL_KEY] = {};
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ADMIN_EVENT_CATALOG,
+  BstageClient,
+  DEFAULT_LANGUAGE,
+  HttpClient,
+  HttpError,
+  HttpTimeoutError,
+  LANGUAGES,
+  PlatformBridge,
+  SLOT_CATALOG,
+  SLOT_CATALOG_V2,
+  VERSION,
+  __resetElementRegistry__,
+  announceElementName,
+  configureBstageI18n,
+  createWebComponent,
+  dirNameToSlotId,
+  fetchTranslations,
+  getAdminEventsByDomain,
+  getSlotsByTarget,
+  getSlotsByTargetV2,
+  interpolateTranslation,
+  isSlotIdV2,
+  lookupElementName,
+  normalizeLanguage,
+  observeLocale,
+  parseRichText,
+  pickTranslation,
+  readLocale,
+  resolveTranslationChain,
+  slotIdToDirName
+});