@ssobig/writer-cli 0.2.0

package/templates/mystery-v1/component-asset-operations.js

@@ -0,0 +1,103 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === "object" && module.exports) module.exports = api;
+  if (root) root.WriterWorkbenchComponentAssetOperations = api;
+})(typeof globalThis !== "undefined" ? globalThis : this, function () {
+  "use strict";
+
+  function characterAssetId(characterId) {
+    return `character-${characterId}`.replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+  }
+
+  function usages(components, dataFor, clueAssetId) {
+    const result = {
+      poster: ["기본정보 · 포스터 이미지"],
+      logo: ["기본정보 · 로고 이미지"],
+      "workspace-background": ["기본정보 · 워크벤치 배경"]
+    };
+    const active = Array.isArray(components) ? components : [];
+    const characterInstance = active.find(instance => instance.templateId === "ssobig.character");
+    const characterData = dataFor(characterInstance) || characterInstance?.data;
+    const deleted = new Set(Array.isArray(characterData?.deletedColumns) ? characterData.deletedColumns : []);
+    for (const characterId of Array.isArray(characterData?.order) ? characterData.order : []) {
+      if (deleted.has(characterId) || !Object.hasOwn(characterData?.characters || {}, characterId)) continue;
+      const assetId = characterAssetId(characterId);
+      if (!result[assetId]) result[assetId] = [];
+      result[assetId].push(`캐릭터 · ${characterData.names?.[characterId] || characterId}`);
+    }
+    const clueInstance = active.find(instance => instance.templateId === "ssobig.clues");
+    const clueData = dataFor(clueInstance) || clueInstance?.data;
+    for (const [index, clue] of (Array.isArray(clueData?.clues) ? clueData.clues : []).entries()) {
+      const assetId = clueAssetId(clue);
+      if (!assetId) continue;
+      if (!result[assetId]) result[assetId] = [];
+      const label = clue.name || clue.title || clue.id || index + 1;
+      result[assetId].push(`단서 · ${label}`);
+    }
+    return result;
+  }
+
+  function create(options) {
+    if (!options?.sync || typeof options?.clone !== "function" || typeof options?.draft !== "function" || typeof options?.clueAssetId !== "function") {
+      throw new Error("Component asset 작업 의존성이 완전하지 않습니다.");
+    }
+
+    function currentManifest() {
+      return options.sync.getAssetManifest?.() || options.clone(options.getAssetInstance?.()?.data || { assets: {} });
+    }
+
+    function currentEntry(assetId) {
+      return options.sync.getAssetEntry?.(assetId) || null;
+    }
+
+    function currentUsages() {
+      return usages(options.activeComponents, instance => options.draft(instance), options.clueAssetId);
+    }
+
+    async function run(ownerInstance, operation) {
+      if (options.isReadOnly?.()) throw new Error("이 작품은 읽기 전용입니다.");
+      if (options.mutationLocked?.()) throw new Error("체크포인트 작업이 끝난 뒤 에셋을 변경해 주세요.");
+      if (ownerInstance && options.saveState(ownerInstance).locked) throw options.saveState(ownerInstance).error;
+      options.setStatus?.({ state: "saving", message: "에셋 파일을 저장하고 있습니다…" });
+      try {
+        const result = await operation();
+        if (ownerInstance) {
+          options.autosave.clearError(ownerInstance.instanceId);
+          options.updateStatus?.(ownerInstance);
+        }
+        options.setStatus?.({ state: "saved", message: "에셋이 저장되어 모든 연결 화면에 반영되었습니다." });
+        options.hydrate?.();
+        return result;
+      } catch (error) {
+        if (ownerInstance) options.autosave.recordError(ownerInstance.instanceId, error);
+        options.setStatus?.({ state: "error", message: error?.message || "에셋을 저장하지 못했습니다." });
+        throw error;
+      }
+    }
+
+    function confirmRemoval(assetId) {
+      if (!currentEntry(assetId)) return false;
+      const linkedUsages = currentUsages()[assetId] || [];
+      const detail = linkedUsages.length ? `\n\n사용처: ${linkedUsages.join(", ")}\n연결된 화면에는 ‘선택된 파일 없음’으로 표시됩니다.` : "";
+      return options.confirm(`‘${assetId}’ 에셋 연결을 해제할까요?${detail}\n\n복제 작품 보호를 위해 기존 Storage 파일은 물리 삭제하지 않습니다.`);
+    }
+
+    function remove(ownerInstance, assetId) {
+      if (!confirmRemoval(assetId)) return Promise.resolve({ cancelled: true });
+      return run(ownerInstance, () => options.sync.deleteAsset(assetId));
+    }
+
+    function applyAppearance() {
+      const basicInstance = options.getBasicInstance?.();
+      if (!basicInstance) return null;
+      return options.appearance.apply(options.draft(basicInstance) || basicInstance.data, {
+        target: options.appearanceTarget,
+        backgroundImageUrl: options.sync.getAssetUrl?.(options.appearance.BACKGROUND_ASSET_ID) || ""
+      });
+    }
+
+    return Object.freeze({ currentManifest, currentEntry, usages: currentUsages, run, confirmRemoval, remove, applyAppearance });
+  }
+
+  return Object.freeze({ characterAssetId, usages, create });
+});

package/templates/mystery-v1/component-autosave.js

@@ -0,0 +1,121 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === "object" && module.exports) module.exports = api;
+  if (root) root.WriterWorkbenchComponentAutosave = api;
+})(typeof globalThis !== "undefined" ? globalThis : this, function () {
+  "use strict";
+
+  function create(options) {
+    const delay = Number(options.delay || 500);
+    const states = new Map();
+    let globalError = null;
+    function state(id) {
+      if (!states.has(id)) states.set(id, { change: 0, saved: 0, timer: null, promise: null, error: null, locked: false, getData: null });
+      return states.get(id);
+    }
+    function notify(id) { options.onStatus?.(id, status(id)); }
+    function status(id) {
+      const current = state(id);
+      if (current.locked) return { state: "error", text: current.error?.message || "외부 변경과 현재 편집이 충돌했습니다. 입력 내용은 보존되었습니다." };
+      if (current.error) return { state: "error", text: `저장 실패 · ${current.error.message}` };
+      if (current.promise) return { state: "saving", text: "자동 저장 중…" };
+      if (current.change > current.saved) return { state: "dirty", text: "변경사항을 자동 저장할 예정입니다." };
+      return { state: "saved", text: "자동 저장됨" };
+    }
+    function schedule(id, getData) {
+      const current = state(id);
+      if (globalError || current.locked) return false;
+      current.change += 1;
+      current.error = null;
+      current.getData = getData;
+      if (current.timer) clearTimeout(current.timer);
+      current.timer = setTimeout(() => { current.timer = null; void flush(id).catch(() => {}); }, delay);
+      notify(id);
+      return true;
+    }
+    async function flush(id) {
+      const current = state(id);
+      if (globalError) throw globalError;
+      if (current.locked) throw current.error;
+      if (current.promise) return current.promise;
+      if (current.saved >= current.change) return;
+      if (current.timer) { clearTimeout(current.timer); current.timer = null; }
+      const targetChange = current.change;
+      const submitted = options.clone(current.getData());
+      options.validate(id, submitted);
+      current.promise = (async () => {
+        try {
+          await options.save(id, submitted);
+          if (globalError) throw globalError;
+          current.saved = targetChange;
+          current.error = null;
+          options.onSaved?.(id, submitted);
+        } catch (error) {
+          current.error = error;
+          if (options.lockOnError === true || options.isConflict?.(error)) current.locked = true;
+          throw error;
+        } finally {
+          current.promise = null;
+          notify(id);
+        }
+        if (current.change > current.saved) return flush(id);
+      })();
+      notify(id);
+      return current.promise;
+    }
+    async function flushAll(ids = [...states.keys()]) {
+      ids.forEach(id => {
+        const current = state(id);
+        if (current.timer) { clearTimeout(current.timer); current.timer = null; }
+      });
+      const results = await Promise.allSettled(ids.map(flush));
+      const failed = results.find(result => result.status === "rejected");
+      if (failed) throw failed.reason;
+    }
+    function hasPendingOrFailure(ids = [...states.keys()]) {
+      return ids.some(id => {
+        const current = state(id);
+        return current.change > current.saved || current.promise || current.error || current.locked;
+      });
+    }
+    function recordError(id, error) {
+      if (options.isConflict?.(error)) return lockAll(error);
+      const current = state(id);
+      current.error = error;
+      if (options.lockOnError === true || options.isConflict?.(error)) current.locked = true;
+      notify(id);
+    }
+    function clearError(id) {
+      const current = state(id);
+      if (current.locked) return false;
+      current.error = null;
+      notify(id);
+      return true;
+    }
+    function lockAll(error, ids = [...states.keys()]) {
+      if (!globalError) globalError = error instanceof Error ? error : new Error(String(error || "새로고침이 필요합니다."));
+      for (const id of ids) {
+        const current = state(id);
+        if (current.timer) clearTimeout(current.timer);
+        current.timer = null;
+        current.error = globalError;
+        current.locked = true;
+        notify(id);
+      }
+      return globalError;
+    }
+    return Object.freeze({
+      state,
+      status,
+      schedule,
+      flush,
+      flushAll,
+      hasPendingOrFailure,
+      recordError,
+      clearError,
+      lockAll,
+      get globalError() { return globalError; }
+    });
+  }
+  return Object.freeze({ create });
+});

package/templates/mystery-v1/component-catalog-contract.js

@@ -0,0 +1,340 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === "object" && module.exports) module.exports = api;
+  if (root) root.WriterWorkbenchComponentCatalogContract = api;
+})(typeof globalThis !== "undefined" ? globalThis : this, function () {
+  "use strict";
+
+  const IMPORT_PROFILE = "writer-import-v1";
+  const TEMPLATE_PATTERN = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/;
+  const INSTANCE_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+  const SUPPORTED_MODES = Object.freeze(["authoring", "preview"]);
+  const ACCESS_MODES = new Set(["read", "read_write"]);
+  const GUIDE_PREVIEW_STATES = new Set(["integrated", "context", "authoring", "internal"]);
+
+  function binding(key, dataTemplateId, accessMode, required = true) {
+    return { key, dataTemplateId, accessMode, required };
+  }
+
+  function view(templateId, instanceId, label, rendererId, bindings) {
+    return { templateId, instanceId, label, rendererId, supportedModes: SUPPORTED_MODES, bindings };
+  }
+
+  function guide(purpose, example, authoring, previewState, preview, relatedTemplateIds, imageAlt) {
+    return {
+      purpose, example, authoring,
+      preview: { state: previewState, description: preview },
+      relatedTemplateIds,
+      image: { src: "", alt: imageAlt }
+    };
+  }
+
+  const RAW_CATALOG = [
+    {
+      templateId: "ssobig.basic", defaultInstanceId: "basic", tabLabel: "기본정보", required: true,
+      description: "작품 제목과 소개, 플레이 인원, 화면 테마 등 기본 설정을 관리합니다.",
+      guide: guide("작품 전체의 정체성과 화면 분위기를 정합니다.", "작품명, 한 줄 소개, 4인용 설정과 대표 색상을 입력합니다.", "제목·인원·소개와 포스터·로고·배경·색상·폰트를 설정합니다.", "integrated", "작품 제목과 테마가 제작 화면과 캐릭터 관점 미리보기 전체에 적용됩니다.", ["ssobig.assets"], "기본정보 제작 화면 예시"),
+      defaultData: null,
+      view: view("ssobig.view.basic-workbench", "basic-workbench", "기본정보 작업 화면", "ssobig.basic", [
+        binding("primary", "ssobig.basic", "read_write"), binding("assets", "ssobig.assets", "read_write")
+      ]),
+      importProfiles: [IMPORT_PROFILE]
+    },
+    {
+      templateId: "ssobig.progress", defaultInstanceId: "progress", tabLabel: "진행", required: true,
+      description: "게임의 단계별 순서와 시간, 플레이어 안내와 진행 행동을 구성합니다.",
+      guide: guide("게임이 어떤 순서와 속도로 진행되는지 설계합니다.", "프롤로그, 1차 조사, 토론, 최종 선택 순서와 시간을 작성합니다.", "단계 이름·시간·안내문·진행 행동을 순서대로 편집합니다.", "integrated", "현재 캐릭터가 확인할 진행 단계와 안내가 통합 미리보기에 표시됩니다.", ["ssobig.common", "ssobig.ending"], "진행 Component 제작 화면 예시"),
+      defaultData: { steps: [] },
+      view: view("ssobig.view.progress-workbench", "progress-workbench", "진행 작업 화면", "ssobig.progress", [
+        binding("primary", "ssobig.progress", "read_write")
+      ]),
+      importProfiles: [IMPORT_PROFILE]
+    },
+    {
+      templateId: "ssobig.common", defaultInstanceId: "common", tabLabel: "공통정보", required: true,
+      description: "모든 플레이어에게 함께 보여줄 게임 규칙과 안내 문서를 작성합니다.",
+      guide: guide("모든 참가자가 공통으로 읽는 규칙과 배경 정보를 작성합니다.", "프롤로그, 조사 규칙, 주의사항과 공통 세계관을 구성합니다.", "기본 문서와 자유 문서의 제목·본문·노출 순서를 편집합니다.", "integrated", "공통 문서는 모든 캐릭터 관점의 통합 미리보기에 함께 표시됩니다.", ["ssobig.progress", "ssobig.character"], "공통정보 제작 화면 예시"),
+      defaultData: { sections: {}, customSections: [], sectionOrder: [], baseTitles: {}, deletedBaseSections: [] },
+      view: view("ssobig.view.common-workbench", "common-workbench", "공통정보 작업 화면", "ssobig.common", [
+        binding("primary", "ssobig.common", "read_write")
+      ]),
+      importProfiles: [IMPORT_PROFILE]
+    },
+    {
+      templateId: "ssobig.choice", defaultInstanceId: "choice", tabLabel: "선택",
+      description: "플레이어가 게임 중간이나 최종 단계에서 고를 수 있는 선택 정보를 작성합니다.",
+      guide: guide("플레이어에게 제시할 선택지와 선택에 필요한 설명을 정리합니다.", "중간 조사 방향이나 최종 범인 지목처럼 플레이어가 결정할 항목을 문서로 구성합니다.", "공통정보와 같은 문서 카드에서 제목·본문·노출 순서를 편집합니다.", "authoring", "선택 문서는 제작 화면의 미리보기에서 공통정보와 같은 카드 형식으로 확인합니다.", ["ssobig.progress", "ssobig.ending"], "선택 제작 화면 예시"),
+      defaultData: { sections: {}, customSections: [], sectionOrder: [], baseTitles: {}, deletedBaseSections: [] },
+      view: view("ssobig.view.choice-workbench", "choice-workbench", "선택 작업 화면", "ssobig.choice", [
+        binding("primary", "ssobig.choice", "read_write")
+      ])
+    },
+    {
+      templateId: "ssobig.character", defaultInstanceId: "characters", tabLabel: "캐릭터", required: true,
+      description: "캐릭터의 이름과 이미지, 공개 정보와 개인 이야기를 작성합니다.",
+      guide: guide("플레이어 캐릭터와 NPC, 각 인물에게 전달할 정보를 설계합니다.", "탐정, 의뢰인 등 인물별 유형과 자유로운 제목·본문 원고를 작성합니다.", "기본정보 Container와 추가 Container에 캐릭터 원고 section을 배치합니다.", "integrated", "플레이어 캐릭터로 지정한 인물의 Container별 원고가 통합 미리보기에 표시됩니다.", ["ssobig.assets", "ssobig.timeline", "ssobig.investigation-board"], "캐릭터 제작 화면 예시"),
+      defaultData: { characters: {}, names: {}, order: [], customCharacters: [], deletedColumns: [] },
+      view: view("ssobig.view.character-workbench", "character-workbench", "캐릭터 작업 화면", "ssobig.character", [
+        binding("primary", "ssobig.character", "read_write"), binding("assets", "ssobig.assets", "read_write")
+      ]),
+      importProfiles: [IMPORT_PROFILE]
+    },
+    {
+      templateId: "ssobig.clues", defaultInstanceId: "clues", tabLabel: "단서",
+      description: "플레이어가 조사하고 획득할 단서의 이미지와 내용을 관리합니다.",
+      guide: guide("조사 과정에서 발견하는 증거와 정보를 정리합니다.", "발견 장소, 단서 이미지, 공개 설명과 작가 메모를 등록합니다.", "단서 이름·제목·설명과 선택 필드·이미지를 표 형태로 편집합니다.", "context", "단서 조합·AI 응답·추리 보드가 단서 ID와 현재 내용을 참고합니다.", ["ssobig.assets", "ssobig.clue-combinations", "ssobig.ai-response", "ssobig.investigation-board"], "단서 제작 화면 예시"),
+      defaultData: { clues: [], enabledOptionalFields: ["confirmed", "image", "location", "tags", "color", "secret"], writerNote: "" },
+      view: view("ssobig.view.clues-workbench", "clues-workbench", "단서 작업 화면", "ssobig.clues", [
+        binding("primary", "ssobig.clues", "read_write"), binding("assets", "ssobig.assets", "read_write")
+      ]),
+      importProfiles: [IMPORT_PROFILE]
+    },
+    {
+      templateId: "ssobig.clue-combinations", defaultInstanceId: "clue-combinations", tabLabel: "단서 조합",
+      description: "여러 단서를 조합했을 때 발견되는 결과와 추가 정보를 설정합니다.",
+      guide: guide("여러 단서가 함께 사용될 때 새로 드러나는 결과를 설계합니다.", "열쇠와 잠긴 상자를 조합하면 비밀 문서가 발견되도록 설정합니다.", "조건 단서와 결과 단서·문구, 힌트를 연결합니다.", "authoring", "현재 통합 미리보기에는 독립 플레이 화면이 없으며 제작 규칙으로 관리됩니다.", ["ssobig.clues"], "단서 조합 제작 화면 예시"),
+      defaultData: { combinations: [] },
+      view: view("ssobig.view.clue-combinations-workbench", "clue-combinations-workbench", "단서 조합 작업 화면", "ssobig.clue-combinations", [
+        binding("primary", "ssobig.clue-combinations", "read_write"), binding("clue-context", "ssobig.clues", "read")
+      ])
+    },
+    {
+      templateId: "ssobig.ai-response", defaultInstanceId: "ai-responses", tabLabel: "AI 응답",
+      description: "플레이어의 질문이나 입력에 따라 보여줄 답변을 설정합니다.",
+      guide: guide("특정 질문이나 문구에 대응하는 자동 답변을 준비합니다.", "인물 이름을 질문하면 준비된 증언이 표시되도록 작성합니다.", "입력 조건과 답변을 응답 단위로 편집합니다.", "authoring", "현재 통합 미리보기에는 독립 플레이 화면이 없으며 응답 규칙을 제작 화면에서 검토합니다.", ["ssobig.clues"], "AI 응답 제작 화면 예시"),
+      defaultData: { responses: [] },
+      view: view("ssobig.view.ai-response-workbench", "ai-response-workbench", "원혼응답 작업 화면", "ssobig.ai-response", [
+        binding("primary", "ssobig.ai-response", "read_write"), binding("clue-context", "ssobig.clues", "read", false)
+      ]),
+      importProfiles: [IMPORT_PROFILE]
+    },
+    {
+      templateId: "ssobig.timeline", defaultInstanceId: "timeline", tabLabel: "타임라인",
+      description: "사건이 일어난 시간과 장소, 캐릭터별 기억과 행동을 시간순으로 정리합니다.",
+      guide: guide("사건의 객관적 흐름과 인물별 기억을 시간축으로 맞춥니다.", "22시 로비 사건과 각 캐릭터가 기억하는 행동을 나란히 기록합니다.", "시간·장소·진실과 캐릭터별 기억을 사건 단위로 편집합니다.", "context", "캐릭터 정보를 읽어 인물별 기억을 연결하지만 독립 플레이 화면은 제공하지 않습니다.", ["ssobig.character"], "타임라인 제작 화면 예시"),
+      defaultData: { events: [] },
+      view: view("ssobig.view.timeline-workbench", "timeline-workbench", "타임라인 작업 화면", "ssobig.timeline", [
+        binding("primary", "ssobig.timeline", "read_write"), binding("character-context", "ssobig.character", "read", false)
+      ]),
+      importProfiles: [IMPORT_PROFILE]
+    },
+    {
+      templateId: "ssobig.ending", defaultInstanceId: "ending", tabLabel: "엔딩",
+      description: "플레이어의 선택과 게임 결과에 따라 공개될 엔딩을 설정합니다.",
+      guide: guide("엔딩이 공개되는 조건과 결말을 연결합니다.", "범인 지목 결과에 따라 성공·실패 결말이 열리도록 구성합니다.", "조건 코드·판정 설명과 결과 문서를 한 쌍으로 편집합니다.", "context", "게임 후 문서가 엔딩을 참고하며 현재 통합 미리보기에는 독립 화면이 없습니다.", ["ssobig.postgame"], "엔딩 제작 화면 예시"),
+      defaultData: { conditions: [], outcomes: [] },
+      view: view("ssobig.view.ending-workbench", "ending-workbench", "엔딩 작업 화면", "ssobig.ending", [
+        binding("primary", "ssobig.ending", "read_write")
+      ]),
+      importProfiles: [IMPORT_PROFILE]
+    },
+    {
+      templateId: "ssobig.postgame", defaultInstanceId: "postgame", tabLabel: "게임 후 문서",
+      description: "게임이 끝난 뒤 공개할 사건의 전말, 에필로그와 추가 문서를 작성합니다.",
+      guide: guide("게임 종료 뒤 참가자에게 공개할 정답과 후일담을 작성합니다.", "사건의 진실, 범행 과정, 캐릭터별 에필로그를 문서로 구성합니다.", "진실·에필로그 문서의 제목·본문과 추가 항목을 편집합니다.", "authoring", "엔딩을 참고하지만 현재 통합 미리보기에는 독립 플레이 화면이 없습니다.", ["ssobig.ending"], "게임 후 문서 제작 화면 예시"),
+      defaultData: { truth: [], epilogue: [], intro: { truth: "", epilogue: "" } },
+      view: view("ssobig.view.postgame-workbench", "postgame-workbench", "게임 후 문서 작업 화면", "ssobig.postgame", [
+        binding("primary", "ssobig.postgame", "read_write"), binding("ending-context", "ssobig.ending", "read", false)
+      ]),
+      importProfiles: [IMPORT_PROFILE]
+    },
+    {
+      templateId: "ssobig.author-notes", defaultInstanceId: "author-notes", tabLabel: "작가노트",
+      description: "작품 제작과 게임 운영에 필요한 메모를 기록합니다.",
+      guide: guide("플레이어에게 공개하지 않을 제작·운영 메모를 보관합니다.", "복선 점검, 진행자 주의사항과 다음 수정 목록을 기록합니다.", "제목과 본문으로 된 자유 메모를 추가하고 정리합니다.", "authoring", "작가 전용 Component로 통합 미리보기에 표시되지 않습니다.", [], "작가노트 제작 화면 예시"),
+      defaultData: { notes: [] },
+      view: view("ssobig.view.author-notes-workbench", "author-notes-workbench", "작가노트 작업 화면", "ssobig.author-notes", [
+        binding("primary", "ssobig.author-notes", "read_write")
+      ]),
+      importProfiles: [IMPORT_PROFILE]
+    },
+    {
+      templateId: "ssobig.investigation-board", defaultInstanceId: "investigation-board", tabLabel: "추리 보드",
+      description: "캐릭터와 단서의 관계를 배치해 사건 구조를 한눈에 정리합니다.",
+      guide: guide("캐릭터·단서·메모의 관계를 공간적으로 검토합니다.", "중심 사건 주변에 인물과 증거를 배치하고 관계선을 연결합니다.", "참조 카드와 포스트잇을 이동·크기 조정하고 관계선을 편집합니다.", "context", "캐릭터·단서·에셋의 현재 값을 읽어 보드에 표시하며 독립 플레이 화면은 없습니다.", ["ssobig.character", "ssobig.clues", "ssobig.assets"], "추리 보드 제작 화면 예시"),
+      defaultData: { viewport: { width: 1600, height: 1000 }, nodes: [], edges: [] },
+      view: view("ssobig.view.investigation-board-workbench", "investigation-board-workbench", "추리 보드 작업 화면", "ssobig.investigation-board", [
+        binding("primary", "ssobig.investigation-board", "read_write"),
+        binding("character-context", "ssobig.character", "read"),
+        binding("clue-context", "ssobig.clues", "read", false),
+        binding("assets", "ssobig.assets", "read")
+      ])
+    },
+    {
+      templateId: "ssobig.assets", defaultInstanceId: "assets", tabLabel: "에셋", required: true, internal: true,
+      description: "작품에서 사용하는 JPEG·PNG·WebP·GIF 이미지와 JSON 파일을 한곳에서 등록하고 관리합니다.",
+      guide: guide("다른 Component가 사용하는 파일의 안전한 포인터를 한곳에서 소유합니다.", "포스터, 로고, 캐릭터·단서 이미지와 보조 JSON을 등록합니다.", "작품 구성의 에셋 탭에서 파일 미리보기·교체·연결 해제를 관리합니다.", "internal", "일반 제작 탭에는 나타나지 않는 내부 필수 Component입니다.", ["ssobig.basic", "ssobig.character", "ssobig.clues", "ssobig.investigation-board"], "에셋 관리 화면 예시"),
+      defaultConfig: { hidden: true }, defaultData: { assets: {} }, importProfiles: [IMPORT_PROFILE]
+    },
+    {
+      templateId: "ssobig.documents", defaultInstanceId: "document", tabLabel: "범용 문서", allowMultiple: true,
+      description: "작품에 필요한 별도의 문서를 자유롭게 추가하고 관리합니다.",
+      guide: guide("고정된 Component에 속하지 않는 보조 문서를 자유롭게 만듭니다.", "진행자 체크리스트나 별도 부록을 독립 탭으로 추가합니다.", "블록 단위의 자유 문서를 작성하며 작품마다 여러 탭을 만들 수 있습니다.", "authoring", "현재 통합 미리보기에는 자동 포함되지 않는 제작용 문서입니다.", [], "범용 문서 제작 화면 예시"),
+      defaultData: { blocks: [] },
+      view: view("ssobig.view.documents-workbench", "documents-workbench", "범용 문서 작업 화면", "ssobig.documents", [
+        binding("primary", "ssobig.documents", "read_write")
+      ])
+    }
+  ];
+
+  function isObject(value) { return Boolean(value && typeof value === "object" && !Array.isArray(value)); }
+  function clone(value) {
+    if (Array.isArray(value)) return value.map(clone);
+    if (isObject(value)) return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clone(item)]));
+    return value;
+  }
+  function deepFreeze(value) {
+    if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+    Object.values(value).forEach(deepFreeze);
+    return Object.freeze(value);
+  }
+  function assertKeys(value, allowed, label) {
+    if (!isObject(value)) throw new TypeError(`${label}은 객체여야 합니다.`);
+    const unexpected = Object.keys(value).find(key => !allowed.includes(key));
+    if (unexpected) throw new TypeError(`${label}.${unexpected}은 지원되지 않습니다.`);
+  }
+  function assertTemplateId(value, label) {
+    const id = String(value || "");
+    if (!TEMPLATE_PATTERN.test(id)) throw new TypeError(`${label} 식별자가 올바르지 않습니다: ${id || "(비어 있음)"}`);
+    return id;
+  }
+  function assertInstanceId(value, label) {
+    const id = String(value || "");
+    if (!INSTANCE_PATTERN.test(id)) throw new TypeError(`${label} 식별자가 올바르지 않습니다: ${id || "(비어 있음)"}`);
+    return id;
+  }
+
+  function normalizeBinding(input, viewTemplateId) {
+    assertKeys(input, ["key", "dataTemplateId", "accessMode", "required"], `${viewTemplateId}.binding`);
+    const key = assertInstanceId(input.key, `${viewTemplateId}.binding.key`);
+    const dataTemplateId = assertTemplateId(input.dataTemplateId, `${viewTemplateId}.${key}.dataTemplateId`);
+    const accessMode = String(input.accessMode || "");
+    if (!ACCESS_MODES.has(accessMode)) throw new TypeError(`${viewTemplateId}.${key}.accessMode가 올바르지 않습니다.`);
+    return { key, dataTemplateId, accessMode, required: input.required !== false };
+  }
+
+  function normalizeView(input, ownerTemplateId) {
+    if (input == null) return null;
+    assertKeys(input, ["templateId", "instanceId", "label", "rendererId", "supportedModes", "bindings"], `${ownerTemplateId}.view`);
+    const templateId = assertTemplateId(input.templateId, `${ownerTemplateId}.view.templateId`);
+    const instanceId = assertInstanceId(input.instanceId, `${ownerTemplateId}.view.instanceId`);
+    const rendererId = assertTemplateId(input.rendererId, `${ownerTemplateId}.view.rendererId`);
+    if (rendererId !== ownerTemplateId) throw new TypeError(`${templateId} renderer는 소유 Data Template과 같아야 합니다.`);
+    const supportedModes = Array.isArray(input.supportedModes) ? [...input.supportedModes].map(String) : [];
+    if (supportedModes.length !== SUPPORTED_MODES.length
+      || new Set(supportedModes).size !== supportedModes.length
+      || supportedModes.some(mode => !SUPPORTED_MODES.includes(mode))) {
+      throw new TypeError(`${templateId}.supportedModes가 올바르지 않습니다.`);
+    }
+    const bindings = (Array.isArray(input.bindings) ? input.bindings : []).map(item => normalizeBinding(item, templateId));
+    if (new Set(bindings.map(item => item.key)).size !== bindings.length) throw new TypeError(`${templateId} binding key가 중복되었습니다.`);
+    const primary = bindings.find(item => item.key === "primary");
+    if (!primary || primary.dataTemplateId !== ownerTemplateId || primary.accessMode !== "read_write" || !primary.required) {
+      throw new TypeError(`${templateId}에는 소유 Data Template의 필수 read_write primary binding이 필요합니다.`);
+    }
+    return { templateId, instanceId, label: String(input.label || templateId), rendererId, supportedModes, bindings };
+  }
+
+  function normalizeDescriptor(input) {
+    assertKeys(input, [
+      "templateId", "defaultInstanceId", "tabLabel", "description", "required", "internal", "allowMultiple",
+      "defaultConfig", "defaultData", "view", "importProfiles", "guide"
+    ], "Component descriptor");
+    const templateId = assertTemplateId(input.templateId, "Component templateId");
+    const defaultConfig = input.defaultConfig === undefined ? {} : input.defaultConfig;
+    if (!isObject(defaultConfig)) throw new TypeError(`${templateId}.defaultConfig는 객체여야 합니다.`);
+    if (input.defaultData !== null && !isObject(input.defaultData)) throw new TypeError(`${templateId}.defaultData는 객체 또는 null이어야 합니다.`);
+    const importProfiles = Array.isArray(input.importProfiles) ? [...input.importProfiles].map(String) : [];
+    if (importProfiles.some(profile => !INSTANCE_PATTERN.test(profile)) || new Set(importProfiles).size !== importProfiles.length) {
+      throw new TypeError(`${templateId}.importProfiles가 올바르지 않습니다.`);
+    }
+    const guideValue = normalizeGuide(input.guide, templateId);
+    return {
+      templateId,
+      defaultInstanceId: assertInstanceId(input.defaultInstanceId, `${templateId}.defaultInstanceId`),
+      tabLabel: String(input.tabLabel || "").trim(),
+      description: String(input.description || ""),
+      required: input.required === true,
+      internal: input.internal === true,
+      allowMultiple: input.allowMultiple === true,
+      defaultConfig: clone(defaultConfig),
+      defaultData: clone(input.defaultData),
+      view: normalizeView(input.view, templateId),
+      importProfiles,
+      guide: guideValue
+    };
+  }
+
+  function normalizeGuide(input, templateId) {
+    assertKeys(input, ["purpose", "example", "authoring", "preview", "relatedTemplateIds", "image"], `${templateId}.guide`);
+    assertKeys(input.preview, ["state", "description"], `${templateId}.guide.preview`);
+    assertKeys(input.image, ["src", "alt"], `${templateId}.guide.image`);
+    const state = String(input.preview.state || "");
+    if (!GUIDE_PREVIEW_STATES.has(state)) throw new TypeError(`${templateId}.guide.preview.state가 올바르지 않습니다.`);
+    const relatedTemplateIds = Array.isArray(input.relatedTemplateIds) ? input.relatedTemplateIds.map(String) : [];
+    if (new Set(relatedTemplateIds).size !== relatedTemplateIds.length || relatedTemplateIds.includes(templateId)) {
+      throw new TypeError(`${templateId}.guide.relatedTemplateIds가 올바르지 않습니다.`);
+    }
+    const requiredText = ["purpose", "example", "authoring"].reduce((output, key) => {
+      const value = String(input[key] || "").trim();
+      if (!value) throw new TypeError(`${templateId}.guide.${key}가 비어 있습니다.`);
+      output[key] = value;
+      return output;
+    }, {});
+    const previewDescription = String(input.preview.description || "").trim();
+    const imageAlt = String(input.image.alt || "").trim();
+    if (!previewDescription || !imageAlt) throw new TypeError(`${templateId}.guide 설명과 이미지 대체 텍스트가 필요합니다.`);
+    return {
+      ...requiredText,
+      preview: { state, description: previewDescription },
+      relatedTemplateIds,
+      image: { src: `./assets/component-guide/${templateId.replace(/\./g, "-")}.webp`, alt: imageAlt }
+    };
+  }
+
+  function createCatalog(input) {
+    if (!Array.isArray(input) || !input.length) throw new TypeError("Component catalog가 비어 있습니다.");
+    const descriptors = input.map(normalizeDescriptor);
+    const byId = new Map();
+    const viewIds = new Set();
+    const instanceIds = new Set();
+    const viewInstanceIds = new Set();
+    for (const descriptor of descriptors) {
+      if (byId.has(descriptor.templateId)) throw new TypeError(`Component Template이 중복되었습니다: ${descriptor.templateId}`);
+      if (instanceIds.has(descriptor.defaultInstanceId)) throw new TypeError(`기본 Component Instance가 중복되었습니다: ${descriptor.defaultInstanceId}`);
+      byId.set(descriptor.templateId, descriptor);
+      instanceIds.add(descriptor.defaultInstanceId);
+      if (descriptor.view && viewIds.has(descriptor.view.templateId)) throw new TypeError(`View Template이 중복되었습니다: ${descriptor.view.templateId}`);
+      if (descriptor.view && viewInstanceIds.has(descriptor.view.instanceId)) throw new TypeError(`기본 View Instance가 중복되었습니다: ${descriptor.view.instanceId}`);
+      if (descriptor.view) {
+        viewIds.add(descriptor.view.templateId);
+        viewInstanceIds.add(descriptor.view.instanceId);
+      }
+    }
+    for (const descriptor of descriptors) {
+      if (descriptor.internal && descriptor.view) throw new TypeError(`${descriptor.templateId} 내부 Component는 소유 View를 가질 수 없습니다.`);
+      for (const binding of descriptor.view?.bindings || []) {
+        if (!byId.has(binding.dataTemplateId)) throw new TypeError(`${descriptor.view.templateId}.${binding.key}가 미등록 Data Template을 가리킵니다.`);
+      }
+      for (const relatedTemplateId of descriptor.guide.relatedTemplateIds) {
+        if (!byId.has(relatedTemplateId)) throw new TypeError(`${descriptor.templateId}.guide가 미등록 Template을 가리킵니다: ${relatedTemplateId}`);
+      }
+    }
+    deepFreeze(descriptors);
+    return Object.freeze({
+      list: () => descriptors.slice(),
+      get: templateId => byId.get(String(templateId || "")) || null,
+      forImportProfile: profile => descriptors.filter(item => item.importProfiles.includes(String(profile || "")))
+    });
+  }
+
+  const catalog = createCatalog(RAW_CATALOG);
+  return Object.freeze({
+    IMPORT_PROFILE,
+    COMPONENTS: deepFreeze(catalog.list()),
+    createCatalog,
+    get: catalog.get,
+    list: catalog.list,
+    forImportProfile: catalog.forImportProfile
+  });
+});