@ssobig/writer-cli 0.2.2 → 0.3.2

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

@@ -1,8 +1,8 @@
 (function (root, factory) {
-  const api = factory();
+  const api = factory(typeof module === "object" && module.exports ? require("./markdown-document-model.js") : root?.WriterMarkdownDocumentModel);
   if (typeof module === "object" && module.exports) module.exports = api;
   if (root) root.WriterWorkbenchComponentAssetOperations = api;
-})(typeof globalThis !== "undefined" ? globalThis : this, function () {
+})(typeof globalThis !== "undefined" ? globalThis : this, function (markdownModel) {
   "use strict";
 
   function characterAssetId(characterId) {
@@ -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;
@@ -34,6 +34,18 @@
       const label = clue.name || clue.title || clue.id || index + 1;
       result[assetId].push(`단서 · ${label}`);
     }
+    for (const instance of active) {
+      if (instance.templateId === "ssobig.assets") continue;
+      const visit = (value, path = []) => {
+        if (typeof value === "string") {
+          const blocks = (markdownModel || globalThis.WriterMarkdownDocumentModel)?.parseDocument(value)?.blocks || [];
+          blocks.filter(block => block.type === "image").forEach(block => {
+            (result[block.assetId] ||= []).push(`${instance.tabLabel || instance.instanceId} · 본문 (${path.join(" / ")})`);
+          });
+        } else if (value && typeof value === "object") Object.entries(value).forEach(([key, child]) => visit(child, [...path, key]));
+      };
+      visit(dataFor(instance) || instance.data);
+    }
     return result;
   }
 
@@ -69,6 +81,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")
         })
@@ -163,7 +170,15 @@
     component({
       templateId: "ssobig.timeline",
       identityPolicy: IDENTITY.UUID,
-      root: shape({ events: field("array", { item: "event" }) }),
+      // 전환기 계약: 사건이 시간을 소유하는 events와 항목이 시간을 소유하는 timeLevels/entries를 상호 배타로 허용한다.
+      // 두 모양의 배타성과 참조 검증은 component-storage-contract의 관계 검증이 담당한다.
+      root: shape({}, {
+        events: field("array", { item: "event" }),
+        timeLevels: field("array", { item: "timeLevel" }),
+        entries: field("array", { item: "entry" }),
+        // 작품의 장소 목록. 배열 순서가 표시 순서이며 v2 모양에서만 사용한다.
+        places: field("array", { item: "place" })
+      }),
       items: {
         event: shape({
           id: field("uuid", { visibility: "hidden" }), time: field("non-empty-string", { role: "display-name" }),
@@ -174,7 +189,44 @@
             values: "memory", keyFormat: "stable-key", keyRole: "unresolved-character-key"
           })
         }),
-        memory: shape({ included: field("boolean"), text: field("string") })
+        memory: shape({ included: field("boolean"), text: field("string") }),
+        timeLevel: shape({
+          id: field("uuid", { role: "technical-identity", visibility: "hidden" }),
+          name: field("non-empty-string", { role: "display-name" }),
+          mode: field("enum", { values: ["manual", "clock"] })
+        }),
+        entry: shape({
+          id: field("uuid", { role: "technical-identity", visibility: "hidden" }),
+          timeLevelId: field("uuid", { references: "timeLevel.id" }),
+          lane: field("object", { item: "entryLane" }),
+          when: field("object", { item: "entryWhen" }),
+          timeLabel: field("string", { role: "display-name" }),
+          text: field("string", { role: "content" }),
+          included: field("boolean")
+        }, {
+          // location은 장소 목록으로 옮기는 동안 유지하는 전환기 fallback 문자열이다.
+          location: field("string"),
+          // 배열 순서는 항목의 이동 경로 순서다.
+          placeIds: field("unique-uuid-array", { references: "place.id" }),
+          eventGroupId: field("uuid", { role: "loose-grouping" })
+        }),
+        place: shape({
+          id: field("uuid", { role: "technical-identity", visibility: "hidden" }),
+          name: field("non-empty-string", { role: "display-name" })
+        }),
+        entryLane: shape({
+          kind: field("enum", { values: ["truth", "character", "unresolved"] })
+        }, {
+          characterId: field("stable-key", { references: "ssobig.character key" }),
+          sourceKey: field("stable-key", { keyRole: "unresolved-character-key" })
+        }),
+        entryWhen: shape({
+          kind: field("enum", { values: ["unspecified", "clock"] })
+        }, {
+          dayOffset: field("non-negative-integer"),
+          startMinute: field("integer", { minimum: 0, maximum: 1439 }),
+          endMinute: field("integer", { minimum: 0, maximum: 1439 })
+        })
       }
     }),
     component({
@@ -192,24 +244,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,
@@ -467,26 +501,53 @@
     }
   }
   function idSet(items) { return new Set(items.map(item => String(item.id || "").toLowerCase())); }
+  function timelineShapeError(data) {
+    const events = Array.isArray(data.events);
+    const levels = Array.isArray(data.timeLevels);
+    const entries = Array.isArray(data.entries);
+    if (events && (levels || entries)) return "$.events와 $.timeLevels/$.entries는 함께 사용할 수 없습니다.";
+    if (!events && !levels && !entries) return "$에는 $.events 또는 $.timeLevels와 $.entries가 있어야 합니다.";
+    if (!events && !(levels && entries)) return "$.timeLevels와 $.entries는 함께 있어야 합니다.";
+    // 장소 목록은 항목이 시간을 소유하는 v2 모양에서만 사용한다.
+    if (events && Object.hasOwn(data, "places")) return "$.places는 $.events 모양에서 사용할 수 없습니다.";
+    return null;
+  }
+  function timelineLaneError(lane, path) {
+    if (lane.kind === "character") {
+      if (!Object.hasOwn(lane, "characterId")) return `${path}.lane에 character 종류의 필수 값이 없습니다.`;
+      return Object.hasOwn(lane, "sourceKey") ? `${path}.lane.sourceKey 필드는 character 종류에서 사용할 수 없습니다.` : null;
+    }
+    if (lane.kind === "unresolved") {
+      if (!Object.hasOwn(lane, "sourceKey")) return `${path}.lane에 unresolved 종류의 필수 값이 없습니다.`;
+      return Object.hasOwn(lane, "characterId") ? `${path}.lane.characterId 필드는 unresolved 종류에서 사용할 수 없습니다.` : null;
+    }
+    const unexpected = ["characterId", "sourceKey"].find(name => Object.hasOwn(lane, name));
+    return unexpected ? `${path}.lane.${unexpected} 필드는 truth 종류에서 사용할 수 없습니다.` : null;
+  }
+  function timelineWhenError(when, level, path) {
+    if (when.kind === "clock") {
+      if (!Object.hasOwn(when, "startMinute")) return `${path}.when에 clock 종류의 필수 값이 없습니다.`;
+      if (Object.hasOwn(when, "endMinute") && when.endMinute < when.startMinute) return `${path}.when.endMinute은 startMinute보다 앞설 수 없습니다.`;
+      return level.mode === "clock" ? null : `${path}.when은 clock 모드 시간 레벨에서만 사용할 수 있습니다.`;
+    }
+    const unexpected = ["dayOffset", "startMinute", "endMinute"].find(name => Object.hasOwn(when, name));
+    return unexpected ? `${path}.when.${unexpected} 필드는 unspecified 종류에서 사용할 수 없습니다.` : null;
+  }
   function validateRelations(contract, data) {
     switch (contract.templateId) {
       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 +569,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;
       }
@@ -569,15 +630,30 @@
         }
         return null;
       }
+      case "ssobig.timeline": {
+        const shapeError = timelineShapeError(data);
+        if (shapeError || Array.isArray(data.events)) return shapeError;
+        // 배열 항목 id 유일성(places 포함)은 array field 검증이 먼저 확인하므로 여기서는 참조와 종류별 규칙만 본다.
+        const levels = new Map(data.timeLevels.map(level => [level.id, level]));
+        const places = idSet(Array.isArray(data.places) ? data.places : []);
+        for (let index = 0; index < data.entries.length; index += 1) {
+          const entry = data.entries[index];
+          const path = `$.entries.${index}`;
+          const level = levels.get(entry.timeLevelId);
+          if (!level) return `${path}.timeLevelId가 존재하지 않는 시간 레벨을 가리킵니다.`;
+          const invalid = timelineLaneError(entry.lane, path) || timelineWhenError(entry.when, level, path);
+          if (invalid) return invalid;
+          if (Array.isArray(entry.placeIds) && entry.placeIds.some(id => !places.has(String(id).toLowerCase()))) {
+            return `${path}.placeIds가 존재하지 않는 장소를 가리킵니다.`;
+          }
+        }
+        return null;
+      }
       case "ssobig.ending": {
         const conditions = idSet(data.conditions), outcomes = idSet(data.outcomes);
         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>`;
   }