@ssobig/writer-cli 0.2.1 → 0.3.0

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

@@ -11,9 +11,9 @@
 
   function usages(components, dataFor, clueAssetId) {
     const result = {
-      poster: ["기본정보 · 포스터 이미지"],
-      logo: ["기본정보 · 로고 이미지"],
-      "workspace-background": ["기본정보 · 워크벤치 배경"]
+      poster: ["디자인 · 포스터 이미지"],
+      logo: ["디자인 · 로고 이미지"],
+      "workspace-background": ["디자인 · 워크벤치 배경"]
     };
     const active = Array.isArray(components) ? components : [];
     const characterInstance = active.find(instance => instance.templateId === "ssobig.character");
@@ -23,7 +23,7 @@
       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}`);
+      result[assetId].push(`캐릭터별 문서 · ${characterData.names?.[characterId] || characterId}`);
     }
     const clueInstance = active.find(instance => instance.templateId === "ssobig.clues");
     const clueData = dataFor(clueInstance) || clueInstance?.data;
@@ -69,6 +69,7 @@
         options.hydrate?.();
         return result;
       } catch (error) {
+        options.onError?.(error);
         if (ownerInstance) options.autosave.recordError(ownerInstance.instanceId, error);
         options.setStatus?.({ state: "error", message: error?.message || "에셋을 저장하지 못했습니다." });
         throw error;

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

@@ -31,9 +31,9 @@
 
   const RAW_CATALOG = [
     {
-      templateId: "ssobig.basic", defaultInstanceId: "basic", tabLabel: "기본정보", required: true,
+      templateId: "ssobig.basic", defaultInstanceId: "basic", tabLabel: "기본정보", displayLabel: "디자인", required: true,
       description: "작품 제목과 소개, 플레이 인원, 화면 테마 등 기본 설정을 관리합니다.",
-      guide: guide("작품 전체의 정체성과 화면 분위기를 정합니다.", "작품명, 한 줄 소개, 4인용 설정과 대표 색상을 입력합니다.", "제목·인원·소개와 포스터·로고·배경·색상·폰트를 설정합니다.", "integrated", "작품 제목과 테마가 제작 화면과 캐릭터 관점 미리보기 전체에 적용됩니다.", ["ssobig.assets"], "기본정보 제작 화면 예시"),
+      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")
@@ -41,9 +41,9 @@
       importProfiles: [IMPORT_PROFILE]
     },
     {
-      templateId: "ssobig.progress", defaultInstanceId: "progress", tabLabel: "진행", required: true,
+      templateId: "ssobig.progress", defaultInstanceId: "progress", tabLabel: "진행", displayLabel: "진행 순서", required: true,
       description: "게임의 단계별 순서와 시간, 플레이어 안내와 진행 행동을 구성합니다.",
-      guide: guide("게임이 어떤 순서와 속도로 진행되는지 설계합니다.", "프롤로그, 1차 조사, 토론, 최종 선택 순서와 시간을 작성합니다.", "단계 이름·시간·안내문·진행 행동을 순서대로 편집합니다.", "integrated", "현재 캐릭터가 확인할 진행 단계와 안내가 통합 미리보기에 표시됩니다.", ["ssobig.common", "ssobig.ending"], "진행 Component 제작 화면 예시"),
+      guide: guide("게임이 어떤 순서와 속도로 진행되는지 설계합니다.", "프롤로그, 1차 조사, 토론, 최종 선택 순서와 시간을 작성합니다.", "단계 이름·시간·안내문·진행 행동을 순서대로 편집합니다.", "integrated", "현재 캐릭터가 확인할 진행 단계와 안내가 통합 미리보기에 표시됩니다.", ["ssobig.common", "ssobig.ending"], "진행 순서 제작 화면 예시"),
       defaultData: { steps: [] },
       view: view("ssobig.view.progress-workbench", "progress-workbench", "진행 작업 화면", "ssobig.progress", [
         binding("primary", "ssobig.progress", "read_write")
@@ -51,28 +51,19 @@
       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: [] },
+      templateId: "ssobig.common", defaultInstanceId: "common", tabLabel: "공통정보", displayLabel: "공통 문서", required: true,
+      description: "모든 플레이어에게 함께 보여줄 게임 규칙, 안내와 펼쳐보기 문서를 작성합니다.",
+      guide: guide("모든 참가자가 공통으로 읽는 규칙과 배경 정보를 작성합니다.", "프롤로그, 조사 규칙, 사건의 전말과 에필로그를 본문과 펼쳐보기로 구성합니다.", "문서의 제목·본문·노출 순서와 문서별 펼쳐보기 항목을 편집합니다.", "integrated", "공통 문서는 펼쳐보기 항목을 포함해 모든 캐릭터 관점의 통합 미리보기에 함께 표시됩니다.", ["ssobig.progress", "ssobig.character", "ssobig.ending"], "공통 문서 제작 화면 예시"),
+      defaultData: { documents: [], deletedDocumentIds: [] },
       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,
+      templateId: "ssobig.character", defaultInstanceId: "characters", tabLabel: "캐릭터", displayLabel: "캐릭터별 문서", required: true,
       description: "캐릭터의 이름과 이미지, 공개 정보와 개인 이야기를 작성합니다.",
-      guide: guide("플레이어 캐릭터와 NPC, 각 인물에게 전달할 정보를 설계합니다.", "탐정, 의뢰인 등 인물별 유형과 자유로운 제목·본문 원고를 작성합니다.", "기본정보 Container와 추가 Container에 캐릭터 원고 section을 배치합니다.", "integrated", "플레이어 캐릭터로 지정한 인물의 Container별 원고가 통합 미리보기에 표시됩니다.", ["ssobig.assets", "ssobig.timeline", "ssobig.investigation-board"], "캐릭터 제작 화면 예시"),
+      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")
@@ -82,8 +73,8 @@
     {
       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: "" },
+      guide: guide("조사 과정에서 발견하는 증거와 정보를 정리합니다.", "발견 장소, 단서 이미지와 공개 설명을 등록합니다.", "단서 이름·제목·설명과 선택 필드·이미지를 표 형태로 편집합니다.", "context", "단서 조합·AI 응답·추리 보드가 단서 ID와 현재 내용을 참고합니다.", ["ssobig.assets", "ssobig.clue-combinations", "ssobig.ai-response", "ssobig.investigation-board"], "단서 제작 화면 예시"),
+      defaultData: { clues: [], enabledOptionalFields: ["confirmed", "image", "location", "tags", "color"] },
       view: view("ssobig.view.clues-workbench", "clues-workbench", "단서 작업 화면", "ssobig.clues", [
         binding("primary", "ssobig.clues", "read_write"), binding("assets", "ssobig.assets", "read_write")
       ]),
@@ -121,23 +112,13 @@
     {
       templateId: "ssobig.ending", defaultInstanceId: "ending", tabLabel: "엔딩",
       description: "플레이어의 선택과 게임 결과에 따라 공개될 엔딩을 설정합니다.",
-      guide: guide("엔딩이 공개되는 조건과 결말을 연결합니다.", "범인 지목 결과에 따라 성공·실패 결말이 열리도록 구성합니다.", "조건 코드·판정 설명과 결과 문서를 한 쌍으로 편집합니다.", "context", "게임 후 문서가 엔딩을 참고하며 현재 통합 미리보기에는 독립 화면이 없습니다.", ["ssobig.postgame"], "엔딩 제작 화면 예시"),
+      guide: guide("엔딩이 공개되는 조건과 결말을 연결합니다.", "범인 지목 결과에 따라 성공·실패 결말이 열리도록 구성합니다.", "조건 코드·판정 설명과 결과 문서를 한 쌍으로 편집합니다.", "context", "현재 통합 미리보기에는 독립 화면이 없습니다.", ["ssobig.common"], "엔딩 제작 화면 예시"),
       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: "작품 제작과 게임 운영에 필요한 메모를 기록합니다.",
@@ -237,7 +218,7 @@
 
   function normalizeDescriptor(input) {
     assertKeys(input, [
-      "templateId", "defaultInstanceId", "tabLabel", "description", "required", "internal", "allowMultiple",
+      "templateId", "defaultInstanceId", "tabLabel", "displayLabel", "description", "required", "internal", "allowMultiple",
       "defaultConfig", "defaultData", "view", "importProfiles", "guide"
     ], "Component descriptor");
     const templateId = assertTemplateId(input.templateId, "Component templateId");
@@ -253,6 +234,7 @@
       templateId,
       defaultInstanceId: assertInstanceId(input.defaultInstanceId, `${templateId}.defaultInstanceId`),
       tabLabel: String(input.tabLabel || "").trim(),
+      displayLabel: String(input.displayLabel || input.tabLabel || "").trim(),
       description: String(input.description || ""),
       required: input.required === true,
       internal: input.internal === true,
@@ -324,7 +306,15 @@
     return Object.freeze({
       list: () => descriptors.slice(),
       get: templateId => byId.get(String(templateId || "")) || null,
-      forImportProfile: profile => descriptors.filter(item => item.importProfiles.includes(String(profile || "")))
+      forImportProfile: profile => descriptors.filter(item => item.importProfiles.includes(String(profile || ""))),
+      displayLabelFor: (input, defaultLabel = "") => {
+        const instance = input && typeof input === "object" ? input : null;
+        const templateId = String(instance?.templateId || input || "");
+        const descriptor = byId.get(templateId) || null;
+        const instanceLabel = String(instance?.tab || "").trim();
+        if (descriptor?.allowMultiple && instanceLabel) return instanceLabel;
+        return String(descriptor?.displayLabel || instanceLabel || defaultLabel || instance?.instanceId || templateId);
+      }
     });
   }
 
@@ -335,6 +325,7 @@
     createCatalog,
     get: catalog.get,
     list: catalog.list,
-    forImportProfile: catalog.forImportProfile
+    forImportProfile: catalog.forImportProfile,
+    displayLabelFor: catalog.displayLabelFor
   });
 });

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

@@ -22,6 +22,10 @@
       now: options.now || Date.now,
       randomUUID: options.randomUUID
     });
+    const characterDefaultColor = () => {
+      const value = String(options.characterDefaultColor?.() || "");
+      return /^#[0-9a-f]{6}$/i.test(value) ? value : "#497fa8";
+    };
 
     function markChange(instance, path, value, changeOptions = {}) {
       if (options.saveState?.(instance)?.locked) return false;
@@ -102,13 +106,21 @@
         occupiedContainers.add(containerId);
         return { id: containerId, role: container.role, title: container.title, sectionIds: [] };
       });
+      const occupiedSections = new Set(Object.values(data.characters).flatMap(record => (record.customSections || []).map(section => section.id)));
+      const publicSectionId = technicalId(instance, "section", occupiedSections);
+      occupiedSections.add(publicSectionId);
+      const initialSectionId = technicalId(instance, "section", occupiedSections);
+      const primaryContainer = containers.find(container => container.role === "primary") || containers[0];
+      primaryContainer.sectionIds.push(publicSectionId, initialSectionId);
       data.characters[id] = {
         isPlayable: true,
-        tag: "Player",
-        color: "#497fa8",
-        customSections: [],
-        containers,
-        authorNote: ""
+        tag: "",
+        color: characterDefaultColor(),
+        customSections: [
+          { id: publicSectionId, title: "공개 정보", body: "" },
+          { id: initialSectionId, title: "새 항목", body: "" }
+        ],
+        containers
       };
       data.names[id] = "새 캐릭터";
       data.order.push(id);
@@ -262,9 +274,8 @@
 
     function commonAdd(instance) {
       const data = options.draft(instance);
-      const id = technicalId(instance, "document", new Set(data.sectionOrder));
-      data.customSections.push({ id, title: instance.templateId === "ssobig.choice" ? "새 선택" : "새 문서", body: "" });
-      data.sectionOrder.push(id);
+      const id = technicalId(instance, "document", new Set(data.documents.map(item => item.id)));
+      data.documents.push({ id, title: "새 문서", body: "", subdocuments: [] });
       persistAndRender(instance);
     }
 

package/templates/mystery-v1/component-field-contracts.js

@@ -36,6 +36,17 @@
     title: field("non-empty-string", { role: "display-title" }),
     body: field("string", { role: "content" })
   });
+  const COMMON_SUBDOCUMENT = shape({
+    id: field("uuid", { role: "technical-identity", visibility: "hidden" }),
+    title: field("non-empty-string", { role: "display-title" }),
+    body: field("string", { role: "content" })
+  }, { displayId: field("string") });
+  const COMMON_DOCUMENT = shape({
+    id: field("uuid", { role: "technical-identity", visibility: "hidden" }),
+    title: field("non-empty-string", { role: "display-title" }),
+    body: field("string", { role: "content" }),
+    subdocuments: field("array", { item: "subdocument" })
+  });
   const CONTRACTS = deepFreeze([
     component({
       templateId: "ssobig.basic",
@@ -58,19 +69,15 @@
         })
       }
     }),
-    ...["ssobig.common", "ssobig.choice"].map(templateId => component({
-      templateId,
+    component({
+      templateId: "ssobig.common",
+      identityPolicy: IDENTITY.UUID,
       root: shape({
-        sections: field("string-map"), customSections: field("array", { item: "section" }),
-        sectionOrder: field("unique-string-array"), baseTitles: field("string-map"),
-        deletedBaseSections: field("unique-string-array")
+        documents: field("array", { item: "document" }),
+        deletedDocumentIds: field("unique-uuid-array")
       }),
-      items: { section: SECTION_ITEM },
-      maps: {
-        sections: field("string-map", { keyRole: "base-section-id", valueRole: "body" }),
-        baseTitles: field("string-map", { keyRole: "base-section-id", valueRole: "title" })
-      }
-    })),
+      items: { document: COMMON_DOCUMENT, subdocument: COMMON_SUBDOCUMENT }
+    }),
     component({
       templateId: "ssobig.character",
       identityPolicy: IDENTITY.STABLE_KEY,
@@ -87,7 +94,7 @@
           customSections: field("array", { item: "section" }),
           containers: field("array", { item: "characterContainer" })
         }, {
-          color: field("hex-color"), tag: field("string"), authorNote: field("string")
+          color: field("hex-color"), tag: field("string")
         }),
         section: SECTION_ITEM,
         characterContainer: shape({
@@ -105,7 +112,7 @@
       root: shape({
         clues: field("array", { item: "clue" }),
         enabledOptionalFields: field("unique-string-array")
-      }, { writerNote: field("string") }),
+      }),
       items: {
         clue: shape({
           id: field("uuid", { role: "technical-identity", visibility: "hidden" }),
@@ -115,7 +122,7 @@
         }, {
           confirmed: field("boolean"), location: field("string"),
           color: field("hex-color-or-empty"), tags: field("unique-non-empty-string-array"), public: field("string"),
-          secret: field("string"), hint: field("string"), room: field("string"), round: field("integer"),
+          hint: field("string"), room: field("string"), round: field("integer"),
           kind: field("string"), point: field("string"), spot: field("string"), character: field("string"),
           related: field("string"), sourceId: field("string"), useTargetType: field("string"), onlyPositiveAllowed: field("boolean")
         })
@@ -192,24 +199,6 @@
         section: SECTION_ITEM
       }
     }),
-    component({
-      templateId: "ssobig.postgame",
-      identityPolicy: IDENTITY.UUID,
-      root: shape({
-        truth: field("array", { item: "document" }), epilogue: field("array", { item: "document" }),
-        intro: field("object", { item: "intro" })
-      }),
-      items: {
-        intro: shape({ truth: field("string"), epilogue: field("string") }),
-        document: shape({
-          id: field("uuid", { visibility: "hidden" }), title: field("non-empty-string", { role: "display-title" }),
-          body: field("string")
-        }, {
-          displayId: field("string"), customSections: field("array", { item: "section" })
-        }),
-        section: SECTION_ITEM
-      }
-    }),
     component({
       templateId: "ssobig.author-notes",
       identityPolicy: IDENTITY.UUID,
@@ -472,21 +461,16 @@
       case "ssobig.basic":
         return data.minPlayers !== undefined && data.maxPlayers !== undefined && data.minPlayers > data.maxPlayers
           ? "$.minPlayers는 $.maxPlayers보다 클 수 없습니다." : null;
-      case "ssobig.common":
-      case "ssobig.choice": {
-        const customIds = idSet(data.customSections);
-        const baseIds = new Set(Object.keys(data.sections));
-        const deleted = new Set(data.deletedBaseSections);
-        if (Object.keys(data.sections).some(id => typeof data.baseTitles[id] !== "string")) return "$.baseTitles는 모든 base section의 제목을 가져야 합니다.";
-        if ([...customIds].some(id => baseIds.has(id))) return "$.customSections id는 base section id와 중복될 수 없습니다.";
-        if (data.deletedBaseSections.some(id => !baseIds.has(id))) return "$.deletedBaseSections에 존재하지 않는 base section이 있습니다.";
-        if (data.sectionOrder.some(id => deleted.has(id) || (!baseIds.has(id) && !customIds.has(id)))) return "$.sectionOrder에 활성 section을 가리키지 않는 값이 있습니다.";
-        const activeIds = new Set([...baseIds].filter(id => !deleted.has(id)).concat([...customIds]));
-        if (data.sectionOrder.length !== activeIds.size || [...activeIds].some(id => !data.sectionOrder.includes(id))) return "$.sectionOrder는 모든 활성 section을 정확히 한 번 포함해야 합니다.";
+      case "ssobig.common": {
+        const documentIds = idSet(data.documents);
+        if (documentIds.size !== data.documents.length) return "$.documents에 중복 document id가 있습니다.";
+        const subdocumentIds = data.documents.flatMap(item => item.subdocuments.map(subdocument => subdocument.id.toLowerCase()));
+        if (new Set(subdocumentIds).size !== subdocumentIds.length) return "$.documents[].subdocuments에 중복 subdocument id가 있습니다.";
+        if (data.deletedDocumentIds.some(id => !documentIds.has(id.toLowerCase()))) return "$.deletedDocumentIds에 존재하지 않는 document id가 있습니다.";
         return null;
       }
       case "ssobig.character": {
-        const allowedOptionalFields = new Set(["image", "color", "tag", "authorNote"]);
+        const allowedOptionalFields = new Set(["image", "color", "tag"]);
         if (Array.isArray(data.enabledOptionalFields) && data.enabledOptionalFields.some(name => !allowedOptionalFields.has(name))) return "$.enabledOptionalFields에 지원하지 않는 캐릭터 선택 속성이 있습니다.";
         const characterIds = new Set(Object.keys(data.characters));
         if ([...characterIds].some(id => typeof data.names[id] !== "string" || !data.names[id].trim())) return "$.names는 모든 character의 표시 이름을 가져야 합니다.";
@@ -508,7 +492,7 @@
         return null;
       }
       case "ssobig.clues": {
-        const allowed = new Set(["confirmed", "image", "location", "tags", "color", "secret"]);
+        const allowed = new Set(["confirmed", "image", "location", "tags", "color"]);
         return data.enabledOptionalFields.some(name => !allowed.has(name))
           ? "$.enabledOptionalFields에 지원하지 않는 단서 선택 속성이 있습니다." : null;
       }
@@ -574,10 +558,6 @@
         if (conditions.size !== outcomes.size || [...conditions].some(id => !outcomes.has(id))) return "$.conditions와 $.outcomes는 같은 id로 정확히 1:1 연결되어야 합니다.";
         return null;
       }
-      case "ssobig.postgame": {
-        const ids = [...data.truth, ...data.epilogue].map(item => item.id.toLowerCase());
-        return new Set(ids).size === ids.length ? null : "$.truth와 $.epilogue에 중복 document id가 있습니다.";
-      }
       default: return null;
     }
   }

package/templates/mystery-v1/component-id-policy.js

@@ -44,7 +44,7 @@
   }
 
   function technicalId(instance, prefix, occupied, options = {}) {
-    const uuidContract = ["ssobig.character", "ssobig.common", "ssobig.choice"].includes(instance.templateId);
+    const uuidContract = ["ssobig.character", "ssobig.common"].includes(instance.templateId);
     if (!uuidContract) return uniqueId(prefix, occupied, options.now || Date.now);
     const randomUUID = options.randomUUID;
     if (typeof randomUUID !== "function") throw new Error("UUID 생성 기능을 사용할 수 없습니다.");

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

@@ -41,7 +41,7 @@
   const FUNCTION_DISPLAY_ORDER = new Map([
     ["ssobig.basic", 0], ["ssobig.progress", 1], ["ssobig.common", 2], ["ssobig.character", 3],
     ["ssobig.timeline", 4], ["ssobig.clues", 5], ["ssobig.clue-combinations", 6],
-    ["ssobig.ai-response", 7], ["ssobig.choice", 8], ["ssobig.ending", 9], ["ssobig.postgame", 10],
+    ["ssobig.ai-response", 7], ["ssobig.ending", 9],
     ["ssobig.author-notes", 11], ["ssobig.investigation-board", 12], ["ssobig.documents", 13]
   ]);
   const DEFAULT_ASSET_SLOTS = Object.freeze([
@@ -156,8 +156,16 @@
     return `<dl class="component-manager-definition-list">${items.map(([label, value]) => `<div><dt>${escapeHtml(label)}</dt><dd>${escapeHtml(value)}</dd></div>`).join("")}</dl>`;
   }
 
-  function relatedViewMarkup(viewComponents) {
+  function componentDisplayLabel(instance, template, defaultLabel = "기능") {
+    const instanceLabel = String(instance?.tab || "").trim();
+    if (template?.allowMultiple && instanceLabel) return instanceLabel;
+    return String(template?.name || instanceLabel || instance?.instanceId || defaultLabel);
+  }
+
+  function relatedViewMarkup(viewComponents, dataTemplateByKey) {
     const labels = viewComponents.map(view => {
+      const templateLabel = dataTemplateByKey.get(view.rendererId)?.name;
+      if (templateLabel) return templateLabel;
       const compactLabel = String(view.label || "").replace(/\s*작업\s*화면\s*$/u, "").trim() || "연결 화면";
       return compactLabel;
     });
@@ -200,12 +208,13 @@
     const required = instance.required || template?.required;
     const selected = selectedId === instance.instanceId;
     const view = primaryView(instance, viewComponents);
+    const label = componentDisplayLabel(instance, template, instance.instanceId);
     return `<article class="component-manager-row is-active${required ? " is-required" : ""}${selected ? " is-selected" : ""}" data-component-row="${escapeHtml(instance.instanceId)}" data-component-state="active" data-component-manager-select="${escapeHtml(instance.instanceId)}" data-component-kind="data" role="button" tabindex="0" aria-pressed="${selected}">
       <div class="component-manager-card-body">
         <span class="component-manager-row-title">
-          <strong>${escapeHtml(instance.tab || instance.instanceId)}</strong>
+          <strong>${escapeHtml(label)}</strong>
           <span class="component-manager-card-status">
-            ${required ? `<span class="component-manager-required-badge">필수</span>` : `<button class="component-manager-toggle is-on" type="button" role="switch" aria-checked="true" aria-label="${escapeHtml(instance.tab)} 사용 해제" data-component-action="archive" data-component-template="${escapeHtml(instance.templateId)}" data-component-instance="${escapeHtml(instance.instanceId)}" data-component-label="${escapeHtml(instance.tab)}"${busy ? " disabled" : ""}><em>사용 중</em><span aria-hidden="true"></span></button>`}
+            ${required ? `<span class="component-manager-required-badge">필수</span>` : `<button class="component-manager-toggle is-on" type="button" role="switch" aria-checked="true" aria-label="${escapeHtml(label)} 사용 해제" data-component-action="archive" data-component-template="${escapeHtml(instance.templateId)}" data-component-instance="${escapeHtml(instance.instanceId)}" data-component-label="${escapeHtml(instance.tab || label)}"${busy ? " disabled" : ""}><em>사용 중</em><span aria-hidden="true"></span></button>`}
           </span>
         </span>
         <span class="component-manager-row-template">${escapeHtml(template?.description || "작품에서 사용하는 기능입니다.")}</span>
@@ -216,7 +225,7 @@
 
   function inactiveComponentRow(instance, template, busy, selectedId) {
     const isArchived = Boolean(instance);
-    const label = instance?.tab || template?.name || instance?.instanceId || "기능";
+    const label = componentDisplayLabel(instance, template);
     const action = isArchived ? "restore" : "add";
     const instanceId = instance?.instanceId || template?.defaultInstanceId || template?.templateId;
     const templateId = instance?.templateId || template?.templateId;
@@ -234,7 +243,7 @@
     </article>`;
   }
 
-  function componentInspector(entry, viewComponents, busy) {
+  function componentInspector(entry, viewComponents, dataTemplateByKey, busy) {
     if (!entry) return `<aside class="component-manager-inspector is-empty" data-component-manager-detail tabindex="-1">
       <div class="component-manager-inspector-empty-guide">
         <strong>세부 설정</strong>
@@ -246,7 +255,7 @@
     const template = entry.template;
     const instanceId = catalogEntryId(entry);
     const templateId = instance?.templateId || template?.templateId || "";
-    const label = instance?.tab || template?.name || instanceId || "기능";
+    const label = componentDisplayLabel(instance, template, instanceId);
     const description = template?.description || (active ? "작품에서 사용하는 기능입니다." : "작품에서 사용할 수 있는 기능입니다.");
     const relatedViews = active ? viewComponents.filter(candidate => candidate.bindings.some(binding => binding.dataInstanceId === instanceId)) : [];
     const view = active ? primaryView(instance, viewComponents) : null;
@@ -268,7 +277,7 @@
       </header>
       <section class="component-manager-inspector-related">
         <strong>사용 위치</strong>
-        ${relatedViewMarkup(relatedViews)}
+        ${relatedViewMarkup(relatedViews, dataTemplateByKey)}
       </section>
       <details class="component-manager-data-details">
         <summary>데이터 정보</summary>
@@ -292,9 +301,10 @@
   }
 
   function restoreCard(instance, template, busy) {
+    const label = componentDisplayLabel(instance, template, instance.instanceId);
     return `<article class="component-add-card is-archived">
-      <div><span>보관됨</span><strong>${escapeHtml(instance.tab || template?.name || instance.instanceId)}</strong><p>기존 내용을 그대로 다시 사용할 수 있습니다.</p></div>
-      <button type="button" data-component-action="restore" data-component-template="${escapeHtml(instance.templateId)}" data-component-instance="${escapeHtml(instance.instanceId)}" data-component-label="${escapeHtml(instance.tab)}"${busy ? " disabled" : ""}>복원</button>
+      <div><span>보관됨</span><strong>${escapeHtml(label)}</strong><p>기존 내용을 그대로 다시 사용할 수 있습니다.</p></div>
+      <button type="button" data-component-action="restore" data-component-template="${escapeHtml(instance.templateId)}" data-component-instance="${escapeHtml(instance.instanceId)}" data-component-label="${escapeHtml(instance.tab || label)}"${busy ? " disabled" : ""}>복원</button>
     </article>`;
   }
 
@@ -382,7 +392,7 @@
         <section class="component-manager-catalog" data-ui-scroll-key="component-manager-catalog" aria-label="작품 기능 목록">
           <div class="component-manager-card-grid">${catalogRows}</div>
         </section>
-        ${componentInspector(selectedEntry, viewComponents, busy)}
+        ${componentInspector(selectedEntry, viewComponents, dataTemplateByKey, busy)}
       </div>${addDialogMarkup(dataComponents, archivedComponents, dataTemplates, busy)}` : assetInstance ? assetLibraryMarkup(assetInstance, options) : `<div class="component-manager-empty">에셋 구성을 찾을 수 없습니다.</div>`}
     </section>`;
   }

package/templates/mystery-v1/component-navigation-counts.js

@@ -10,11 +10,8 @@
   }
 
   function commonCount(data) {
-    const sections = data?.sections && typeof data.sections === "object" ? data.sections : {};
-    const deleted = new Set(Array.isArray(data?.deletedBaseSections) ? data.deletedBaseSections : []);
-    const customIds = new Set((Array.isArray(data?.customSections) ? data.customSections : []).map(item => item?.id).filter(Boolean));
-    return (Array.isArray(data?.sectionOrder) ? data.sectionOrder : [])
-      .filter(id => !deleted.has(id) && (Object.hasOwn(sections, id) || customIds.has(id))).length;
+    const deleted = new Set(Array.isArray(data?.deletedDocumentIds) ? data.deletedDocumentIds : []);
+    return (Array.isArray(data?.documents) ? data.documents : []).filter(document => !deleted.has(document?.id)).length;
   }
 
   function characterCount(data) {
@@ -38,8 +35,7 @@
   function componentItemCount(instance, data = instance?.data) {
     switch (String(instance?.templateId || "")) {
       case "ssobig.progress": return listLength(data?.steps);
-      case "ssobig.common":
-      case "ssobig.choice": return commonCount(data);
+      case "ssobig.common": return commonCount(data);
       case "ssobig.character": return characterCount(data);
       case "ssobig.clues": return listLength(data?.clues);
       case "ssobig.clue-combinations": return listLength(data?.combinations);
@@ -47,7 +43,6 @@
       case "ssobig.timeline": return listLength(data?.events);
       case "ssobig.investigation-board": return listLength(data?.nodes);
       case "ssobig.ending": return endingCount(data);
-      case "ssobig.postgame": return listLength(data?.truth) + listLength(data?.epilogue);
       case "ssobig.author-notes": return listLength(data?.notes);
       case "ssobig.documents": return listLength(data?.blocks);
       default: return 0;

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

@@ -48,8 +48,7 @@
     { key: "image", label: "이미지", description: "단서 이미지 등록과 미리보기" },
     { key: "location", label: "위치", description: "단서를 발견하거나 사용하는 위치" },
     { key: "tags", label: "태그", description: "단서 분류와 미리보기 필터" },
-    { key: "color", label: "컬러", description: "단서 분류용 대표 색상" },
-    { key: "secret", label: "작가 노트", description: "제작자만 확인하는 단서 메모" }
+    { key: "color", label: "컬러", description: "단서 분류용 대표 색상" }
   ]);
 
   const BASIC_FIELD_CONFIGURATION = deepFreeze([
@@ -73,8 +72,7 @@
     { key: "containers", label: "원고 Container", required: true, description: "캐릭터 기본정보와 원고 section의 묶음·순서" },
     { key: "image", label: "캐릭터 이미지", required: true, description: "캐릭터 이미지 등록과 미리보기" },
     { key: "color", label: "컬러", required: true, description: "캐릭터 카드의 대표 색상" },
-    { key: "tag", label: "태그", required: true, description: "캐릭터의 역할과 분류 태그" },
-    { key: "authorNote", label: "작가 노트", description: "연기 방향과 설계 의도 메모" }
+    { key: "tag", label: "태그", required: true, description: "캐릭터의 역할과 분류 태그" }
   ]);
 
   function template(input) {
@@ -113,7 +111,7 @@
 
   const INITIAL_TEMPLATE_CATALOG = deepFreeze(catalogContract.list().map(descriptor => template({
     templateId: descriptor.templateId,
-    name: descriptor.tabLabel,
+    name: descriptor.displayLabel,
     required: descriptor.required,
     internal: descriptor.internal,
     allowMultiple: descriptor.allowMultiple,
@@ -186,12 +184,20 @@
       return selected.allowMultiple || !instances.some(instance => instance?.templateId === selected.templateId);
     }
 
+    function displayLabelFor(instance, defaultLabel = "") {
+      const selected = get(instance?.templateId);
+      const instanceLabel = String(instance?.tab || "").trim();
+      if (selected?.allowMultiple && instanceLabel) return instanceLabel;
+      return String(selected?.name || instanceLabel || defaultLabel || instance?.instanceId || instance?.templateId || "");
+    }
+
     initialTemplates.forEach(item => register(item));
     return Object.freeze({
       register,
       get,
       has: id => Boolean(get(id)),
       canInstantiate,
+      displayLabelFor,
       list: () => [...templates.values()].sort((left, right) => left.templateId.localeCompare(right.templateId))
     });
   }