@ssobig/writer-cli 0.3.2 → 0.3.4

package/templates/mystery-v1/markdown-toolbar.js

@@ -0,0 +1,514 @@
+(function (root, 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.WriterMarkdownToolbar = api;
+})(typeof globalThis !== "undefined" ? globalThis : this, function (documentModel) {
+  "use strict";
+  const marks = Object.freeze({
+    bold: "**",
+    italic: "*",
+    underline: "<u>",
+    strike: "~~",
+    highlight: "==",
+    brand: "++",
+  });
+  const tools = [
+    ["undo", "실행 취소"],
+    ["redo", "다시 실행"],
+    ["bold", "굵게"],
+    ["italic", "기울임"],
+    ["underline", "밑줄"],
+    ["strike", "취소선"],
+    ["highlight", "형광펜"],
+    ["brand", "색글씨"],
+    ["paragraph", "일반 본문"],
+    ["h1", "제목 1"],
+    ["h2", "제목 2"],
+    ["h3", "제목 3"],
+    ["bullet", "글머리 목록"],
+    ["number", "숫자 목록"],
+    ["task", "체크박스 목록"],
+    ["quote", "인용"],
+    ["image", "이미지 삽입"],
+    ["divider", "구분선"],
+    ["table", "표 만들기"],
+    ["table-delete", "현재 표 삭제"],
+  ];
+  // Local vector icons share one stroke style and need no font or network asset.
+  const iconPaths = Object.freeze({
+    bold: "M6 4h7a4 4 0 0 1 0 8H6V4m0 8h8a4 4 0 0 1 0 8H6v-8",
+    italic: "M10 4h10M4 20h10M15 4 9 20",
+    underline: "M6 3v8a6 6 0 0 0 12 0V3M4 21h16",
+    strike: "M18 6c-1-2-3-3-6-3-4 0-6 2-6 5 0 2 2 3 6 4M6 18c1 2 3 3 6 3 4 0 6-2 6-5 0-1-1-2-2-3M3 12h18",
+    highlight: "m10 10 8-8 4 4-8 8-4-4ZM10 10l-3 3 4 4 3-3M7 13l-3 5h5l2-1",
+    brand: "m4 14 9-11a2 2 0 0 1 3 0l2 2a2 2 0 0 1 0 3L7 17l-3-3ZM4 14l-2 6 5-3M11 5l5 5M19 13c-1 2-3 4-3 5.5a3 3 0 0 0 6 0C22 17 20 15 19 13Z",
+    image: "M13 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-8M3 16l5-5 8 10M12 17l3-3 6 6M18 2v6M15 5h6M8 7h.01",
+    paragraph: "M4 4h16M12 4v16",
+    h1: "M3 5v14M12 5v14M3 12h9M16 12l3-2v9M16 19h6",
+    h2: "M3 5v14M12 5v14M3 12h9M16 12a3 3 0 0 1 6 0c0 2-6 4-6 7h6",
+    h3: "M3 5v14M12 5v14M3 12h9M16 10h6l-4 4c5-1 5 6 1 6-2 0-3-1-3-2",
+    bullet: "M9 5h12M9 12h12M9 19h12M3 5h1M3 12h1M3 19h1",
+    task: "M3 3h18v18H3V3m4 9 3 3 7-7",
+    number: "M10 5h11M10 12h11M10 19h11M3 3h1v4M2 7h4M2 11c0-2 4-2 4 0 0 1-4 2-4 4h4M2 18h4l-2 2c3-1 3 3 0 3H2",
+    quote: "M3 5h7v7H3V5m7 7c0 4-2 6-5 7M14 5h7v7h-7V5m7 7c0 4-2 6-5 7",
+    divider: "M3 12h18M8 5h8M8 19h8",
+    table: "M12 3H3v18h18v-9M3 9h9M3 15h18M9 3v18M18 2v8M14 6h8",
+    "table-delete": "M12 3H3v18h18v-9M3 9h9M3 15h18M9 3v18m6-16 7 7m0-7-7 7",
+    undo: "M9 4 3 10l6 6M3 10h11a5 5 0 0 1 0 10h-3",
+    redo: "m15 4 6 6-6 6M21 10H10a5 5 0 0 0 0 10h3",
+  });
+  function createIcon(doc, command) {
+    const ns = "http://www.w3.org/2000/svg";
+    const svg = doc.createElementNS(ns, "svg");
+    svg.setAttribute("viewBox", "0 0 24 24");
+    svg.setAttribute("aria-hidden", "true");
+    svg.setAttribute("focusable", "false");
+    if (command === "highlight") {
+      const swatch = doc.createElementNS(ns, "rect");
+      for (const [key, value] of Object.entries({ x: "2", y: "20", width: "20", height: "4", rx: "1", class: "writer-format-highlight-swatch" })) {
+        swatch.setAttribute(key, value);
+      }
+      svg.append(swatch);
+    }
+    const path = doc.createElementNS(ns, "path");
+    path.setAttribute("d", iconPaths[command]);
+    svg.append(path);
+    return svg;
+  }
+  // Pure source edits. The editor remains the sole selection/history/save owner.
+  function inlineSelectionParts(source, from, to, tokens = []) {
+    const parsed = documentModel.parseDocument(source, { preserveBlankLines: true });
+    const excluded = new Set(parsed.blocks.flatMap(block => block.type === "table"
+      ? block.lineIndices : ["horizontalRule", "image"].includes(block.type) ? [block.lineIndex] : []));
+    return parsed.lines.flatMap(line => {
+      if (excluded.has(line.index)) return [];
+      const prefix = Math.max(0, line.headingMarkerTo, line.quoteMarkerTo, line.taskMarkerTo, line.listPrefixTo);
+      let parts = [{from:Math.max(from, line.from + prefix), to:Math.min(to, line.to)}];
+      for (const token of tokens.filter(token => token.type === "code")) {
+        parts = parts.flatMap(part => token.to <= part.from || token.from >= part.to ? [part] : [
+          {from:part.from, to:Math.min(part.to, token.from)},
+          {from:Math.max(part.from, token.to), to:part.to}
+        ]);
+      }
+      return parts.flatMap(part => {
+        if (part.to <= part.from) return [];
+        const text = source.slice(part.from, part.to);
+        const start = part.from + text.length - text.trimStart().length;
+        const end = part.to - (text.length - text.trimEnd().length);
+        return end > start ? [{from:start, to:end}] : [];
+      });
+    });
+  }
+  function partMark(part, command, tokens) {
+    return tokens.find(token => (token.marker === marks[command] || (command === "italic" && token.marker === "_"))
+      && part.from >= token.from && part.to <= token.to
+      && part.to > token.contentFrom && part.from < token.contentTo);
+  }
+  function multilineChange(source, anchor, head, command, tokens) {
+    const from = Math.min(anchor, head), to = Math.max(anchor, head);
+    const parts = inlineSelectionParts(source, from, to, tokens);
+    if (!parts.length) return null;
+    const marked = parts.map(part => partMark(part, command, tokens));
+    const remove = marked.every(Boolean);
+    const edits = [];
+    parts.forEach((part, index) => {
+      const token = marked[index];
+      if (remove) {
+        edits.push({from:token.from, to:token.contentFrom, insert:""}, {from:token.contentTo, to:token.to, insert:""});
+      } else if (!token) {
+        edits.push({from:part.from, to:part.from, insert:marks[command]},
+          {from:part.to, to:part.to, insert:command === "underline" ? "</u>" : marks[command]});
+      }
+    });
+    const changes = [...new Map(edits.map(edit => [`${edit.from}:${edit.to}`, edit])).values()].sort((a,b) => a.from - b.from);
+    const mapPosition = (position, side) => {
+      let delta = 0;
+      for (const edit of changes) {
+        if (position < edit.from || (position === edit.from && side < 0)) break;
+        if (position < edit.to) return edit.from + delta;
+        delta += edit.insert.length - (edit.to - edit.from);
+      }
+      return position + delta;
+    };
+    const start = mapPosition(from, 1), end = mapPosition(to, -1);
+    return {changes, selection:anchor <= head ? {anchor:start,head:end} : {anchor:end,head:start}};
+  }
+  function change(source, anchor, head, command, tokens = []) {
+    const from = Math.min(anchor, head),
+      to = Math.max(anchor, head);
+    const selected = source.slice(from, to),
+      marker = marks[command];
+    if (marker) {
+      const closeMarker = command === "underline" ? "</u>" : marker;
+      if (selected.includes("\n")) return multilineChange(source, anchor, head, command, tokens);
+      const token = tokens.find(
+        (t) =>
+          (t.marker === marker || (command === "italic" && t.marker === "_")) && from >= t.contentFrom && to <= t.contentTo,
+      );
+      if (token) {
+        return {
+          changes: [
+            { from: token.from, to: token.contentFrom },
+            { from: token.contentTo, to: token.to },
+          ],
+          selection: {
+            anchor: anchor - (token.contentFrom - token.from),
+            head: head - (token.contentFrom - token.from),
+          },
+        };
+      }
+      if (
+        selected.length >= marker.length + closeMarker.length &&
+        selected.startsWith(marker) &&
+        selected.endsWith(closeMarker)
+      ) {
+        const text = selected.slice(marker.length, -closeMarker.length);
+        return {
+          changes: { from, to, insert: text },
+          selection: { anchor: from, head: from + text.length },
+        };
+      }
+      if (
+        source.slice(Math.max(0, from - marker.length), from) === marker &&
+        source.slice(to, to + closeMarker.length) === closeMarker
+      ) {
+        return {
+          changes: [
+            { from: from - marker.length, to: from },
+            { from: to, to: to + closeMarker.length },
+          ],
+          selection: {
+            anchor: anchor - marker.length,
+            head: head - marker.length,
+          },
+        };
+      }
+      return {
+        changes: { from, to, insert: marker + selected + closeMarker },
+        selection: {
+          anchor: anchor + marker.length,
+          head: head + marker.length,
+        },
+      };
+    }
+    if (command === "divider" || command === "table") {
+      const text =
+        command === "divider"
+          ? "---"
+          : "| 제목 | 내용 |\n| --- | --- |\n|  |  |";
+      const prefix =
+        from && !source.slice(0, from).endsWith("\n\n")
+          ? source[from - 1] === "\n"
+            ? "\n"
+            : "\n\n"
+          : "";
+      const suffix = source.slice(to).startsWith("\n\n")
+        ? ""
+        : source[to] === "\n"
+          ? "\n"
+          : "\n\n";
+      const position =
+        from +
+        prefix.length +
+        (command === "table" ? 2 : text.length + suffix.length);
+      return {
+        changes: { from, to, insert: prefix + text + suffix },
+        selection: { anchor: position },
+      };
+    }
+    if (
+      !["paragraph", "h1", "h2", "h3", "bullet", "number", "task", "quote"].includes(
+        command,
+      )
+    )
+      return null;
+    const start = from === 0 ? 0 : source.lastIndexOf("\n", from - 1) + 1;
+    const endPosition = to > from && source[to - 1] === "\n" ? to - 1 : to;
+    const nextBreak = source.indexOf("\n", endPosition),
+      end = nextBreak < 0 ? source.length : nextBreak;
+    const lines = source.slice(start, end).split("\n");
+    const pattern = /^(\s*)(?:[-*] \[[ xX]\](?:[ \t]+|$)|#{1,6} |[-+*] |\d+[.)] |> )/;
+    const prefixFor = (index) =>
+      command === "paragraph"
+        ? ""
+        : command[0] === "h"
+          ? "#".repeat(Number(command[1])) + " "
+          : command === "bullet"
+            ? "- "
+            : command === "task"
+              ? "- [ ] "
+            : command === "number"
+              ? `${index + 1}. `
+              : "> ";
+    const same =
+      command !== "paragraph" &&
+      lines.every((line) => {
+        const prefix = line.match(pattern)?.[0]?.trim() || "";
+        return command === "task" ? /^[-*] \[[ xX]\]$/.test(prefix) : command === "number"
+          ? /^\d+[.)]$/.test(prefix)
+          : prefix === prefixFor(0).trim();
+      });
+    let offset = start;
+    const changes = lines.map((line, index) => {
+      const match = line.match(pattern),
+        indentation = match?.[1] || line.match(/^\s*/)[0];
+      const removed = match ? match[0].length : indentation.length;
+      const result = {
+        from: offset,
+        to: offset + removed,
+        insert: indentation + (same ? "" : prefixFor(index)),
+      };
+      offset += line.length + 1;
+      return result;
+    });
+    const map = (position) => {
+      let delta = 0;
+      for (const edit of changes) {
+        if (position < edit.from) break;
+        if (position <= edit.to) return edit.from + delta + edit.insert.length;
+        delta += edit.insert.length - (edit.to - edit.from);
+      }
+      return position + delta;
+    };
+    return { changes, selection: { anchor: map(anchor), head: map(head) } };
+  }
+
+  const documents = new WeakMap();
+  function openTableDialog(doc, manager, command) {
+    if (manager.dialog) return;
+    const current = manager.active;
+    const original = current?.context();
+    if (!original || current.disabledReason(command)) return;
+    const creating = command === "table";
+    const dialog = doc.createElement("dialog");
+    dialog.className = "writer-format-dialog";
+    dialog.setAttribute("aria-label", creating ? "표 만들기" : "현재 표 삭제");
+    const heading = doc.createElement("h3");
+    heading.textContent = creating ? "표 만들기" : "현재 표를 삭제할까요?";
+    const description = doc.createElement("p");
+    description.textContent = creating ? "제목 행은 따로 추가됩니다. 표 안에서는 현재 표 바로 뒤에 만듭니다." : "이 표의 모든 셀 내용이 삭제됩니다. 삭제 후 실행 취소로 복원할 수 있습니다.";
+    const form = doc.createElement("form");
+    const inputs = {};
+    if (creating) {
+      for (const [name, label, value, max] of [["columns", "열 수", 2, 12], ["rows", "내용 행 수", 3, 30]]) {
+        const field = doc.createElement("label");
+        field.textContent = label;
+        const input = doc.createElement("input");
+        Object.assign(input, { type: "number", min: "1", max: String(max), step: "1", value: String(value), required: true });
+        input.setAttribute("aria-label", label);
+        field.append(input); form.append(field); inputs[name] = input;
+      }
+    }
+    const actions = doc.createElement("div");
+    actions.className = "writer-format-dialog-actions";
+    const cancel = doc.createElement("button");
+    cancel.type = "button"; cancel.textContent = "취소";
+    const submit = doc.createElement("button");
+    submit.type = "submit"; submit.textContent = creating ? "표 만들기" : "표 삭제";
+    submit.className = creating ? "primary" : "danger";
+    actions.append(cancel, submit); form.append(actions); dialog.append(heading, description, form);
+    let settled = false;
+    const finish = apply => {
+      if (settled) return;
+      settled = true;
+      const context = current.context();
+      const unchanged = context && context.source === original.source && context.selection.anchor === original.selection.anchor && context.selection.head === original.selection.head;
+      dialog.close(); dialog.remove(); manager.dialog = null;
+      if (context) current.focus();
+      if (apply && unchanged) current.run(command, creating ? { columns: Number(inputs.columns.value), rows: Number(inputs.rows.value) } : undefined);
+      manager.update();
+    };
+    cancel.addEventListener("click", () => finish(false));
+    dialog.addEventListener("cancel", event => { event.preventDefault(); finish(false); });
+    form.addEventListener("submit", event => { event.preventDefault(); if (form.reportValidity()) finish(true); });
+    manager.dialog = dialog;
+    manager.bar.append(dialog);
+    dialog.showModal();
+    (creating ? inputs.columns : cancel).focus();
+  }
+  function viewportInset(frameHeight, visibleBottom, frameTop = 0, scale = 1) {
+    return Math.max(0, frameHeight - Math.max(0, (visibleBottom - frameTop) / scale));
+  }
+  function register(doc, target) {
+    let manager = documents.get(doc);
+    if (!manager) {
+      const win = doc.defaultView;
+      const bar = doc.createElement("div");
+      bar.className = "writer-format-toolbar";
+      bar.dataset.editing = "false";
+      bar.inert = true;
+      bar.setAttribute("aria-hidden", "true");
+      bar.setAttribute("role", "toolbar");
+      bar.setAttribute("aria-label", "텍스트 편집 도구");
+      const strip = doc.createElement("div");
+      strip.className = "writer-format-tools";
+      const buttons = new Map();
+      manager = { bar, targets: new Set(), active: null };
+      for (const [command, label] of tools) {
+        const button = doc.createElement("button");
+        button.type = "button";
+        button.setAttribute("aria-label", label);
+        button.append(createIcon(doc, command));
+        button.dataset.formatCommand = command;
+        if (["bold", "paragraph", "bullet", "image"].includes(command)) {
+          const separator = doc.createElement("span");
+          separator.className = "writer-format-separator";
+          separator.setAttribute("aria-hidden", "true");
+          strip.append(separator);
+        }
+        button.addEventListener("click", () => {
+          const current = manager.active;
+          if (!current || button.disabled) return;
+          if (command === "table" || command === "table-delete") openTableDialog(doc, manager, command);
+          else current.run(command);
+          manager.update();
+        });
+        buttons.set(command, button);
+        strip.append(button);
+      }
+      bar.append(strip);
+      doc.body.append(bar);
+      doc.body.classList.add("writer-has-format-toolbar");
+      // Keep pointer/touch actions from moving focus out of the editor.
+      bar.addEventListener("pointerdown", (event) => {
+        if (!event.target.closest("dialog") && event.target.closest("button") && event.button === 0)
+          event.preventDefault();
+      });
+      bar.addEventListener("keydown", (event) => {
+        if (event.target.closest("dialog")) return;
+        if (event.key === "Escape") {
+          event.preventDefault();
+          manager.active?.focus();
+        }
+      });
+      manager.focus = () =>
+        [...buttons.values()].find((button) => !button.disabled)?.focus();
+      manager.update = () => {
+        const current = manager.active;
+        const context = current?.context();
+        const editing = String(Boolean(context));
+        if (bar.dataset.editing !== editing) {
+          bar.dataset.editing = editing;
+          bar.inert = !context;
+          bar.setAttribute("aria-hidden", String(!context));
+          manager.position?.();
+        }
+        for (const [command, button] of buttons) {
+          const reason = context
+            ? current.disabledReason(command)
+            : "본문을 먼저 선택하세요";
+          button.disabled = Boolean(reason);
+          button.title = reason || button.getAttribute("aria-label");
+          if (marks[command])
+            button.setAttribute(
+              "aria-pressed",
+              String(Boolean(context?.marks?.includes(command))),
+            );
+        }
+      };
+      const onFocus = (event) => {
+        if (bar.contains(event.target)) return;
+        const current = [...manager.targets].find(
+          (item) => item.contains(event.target) && item.context(),
+        );
+        if (manager.active && manager.active !== current)
+          manager.active.blur?.();
+        manager.active = current || null;
+        manager.update();
+      };
+      const onBlur = () =>
+        setTimeout(() => {
+          if (bar.contains(doc.activeElement)) return;
+          if (manager.active && !manager.active.contains(doc.activeElement)) {
+            manager.active.blur?.();
+            manager.active = null;
+            manager.update();
+          }
+        }, 0);
+      // Convert the parent's visible bottom into this iframe's coordinates.
+      // A keyboard inset alone is wrong when 100vh exceeds the visible viewport.
+      let viewportWindow = win;
+      let frame = null;
+      try {
+        if (
+          win.parent !== win &&
+          win.parent.location.origin === win.location.origin
+        ) {
+          viewportWindow = win.parent;
+          frame = win.frameElement;
+        }
+      } catch (_) {}
+      const viewport = viewportWindow.visualViewport;
+      const position = () => {
+        const visibleBottom = viewport ? viewport.height + viewport.offsetTop : viewportWindow.innerHeight;
+        const rect = frame?.getBoundingClientRect();
+        const scale = rect && frame.offsetHeight ? rect.height / frame.offsetHeight : 1;
+        const top = rect ? rect.top + frame.clientTop * scale : 0;
+        const inset = viewportInset(win.innerHeight, visibleBottom, top, scale || 1);
+        bar.style.bottom = `${inset}px`;
+        doc.body.style.setProperty("--writer-visible-bottom-inset", `${inset}px`);
+        doc.body.style.setProperty("--writer-toolbar-clearance", `${inset + bar.offsetHeight}px`);
+      };
+      manager.position = position;
+      doc.addEventListener("focusin", onFocus);
+      doc.addEventListener("focusout", onBlur);
+      viewport?.addEventListener("resize", position);
+      viewport?.addEventListener("scroll", position);
+      win.addEventListener("resize", position);
+      viewportWindow.addEventListener("scroll", position, true);
+      if (viewportWindow !== win) viewportWindow.addEventListener("resize", position);
+      const sizeObserver = new win.ResizeObserver(position);
+      sizeObserver.observe(bar, { box: "border-box" });
+      position();
+      manager.dispose = () => {
+        sizeObserver.disconnect();
+        doc.removeEventListener("focusin", onFocus);
+        doc.removeEventListener("focusout", onBlur);
+        viewport?.removeEventListener("resize", position);
+        viewport?.removeEventListener("scroll", position);
+        win.removeEventListener("resize", position);
+        viewportWindow.removeEventListener("scroll", position, true);
+        if (viewportWindow !== win) viewportWindow.removeEventListener("resize", position);
+        bar.remove();
+        doc.body.style.removeProperty("--writer-visible-bottom-inset");
+        doc.body.style.removeProperty("--writer-toolbar-clearance");
+        doc.body.classList.remove("writer-has-format-toolbar");
+        documents.delete(doc);
+      };
+      documents.set(doc, manager);
+      manager.update();
+    }
+    manager.targets.add(target);
+    return {
+      ownsFocus: () =>
+        manager.active === target && manager.bar.contains(doc.activeElement),
+      focus() {
+        if (manager.active === target) manager.focus();
+      },
+      refresh() {
+        // Touch can focus a readonly editor before it becomes editable, without
+        // firing another focusin. Reconnect from the current focus on that update.
+        if (manager.active !== target && target.contains(doc.activeElement) && target.context()) {
+          manager.active?.blur?.();
+          manager.active = target;
+        }
+        if (manager.active === target) {
+          if (!target.context()) manager.active = null;
+          manager.update();
+        }
+      },
+      destroy() {
+        manager.targets.delete(target);
+        if (manager.active === target) {
+          manager.dialog?.remove();
+          manager.dialog = null;
+          manager.active = null;
+        }
+        if (!manager.targets.size) manager.dispose();
+        else manager.update();
+      },
+    };
+  }
+  return Object.freeze({ change, register, marks, viewportInset, inlineSelectionParts, partMark });
+});

package/templates/mystery-v1/timeline-model.js

@@ -16,6 +16,7 @@
   // events는 사건이 시간을 소유하는 legacy 모양, timeLevels/entries는 항목이 시간을 소유하는 v2 모양이다.
   function detectShape(data) {
     if (!isObject(data)) return "invalid";
+    if (Object.hasOwn(data, "timeGroups")) return Array.isArray(data.timeGroups) && Array.isArray(data.events) && Array.isArray(data.places) && !Object.hasOwn(data, "timeLevels") && !Object.hasOwn(data, "entries") ? "events" : "invalid";
     const events = Array.isArray(data.events);
     const levels = Array.isArray(data.timeLevels);
     const entries = Array.isArray(data.entries);
@@ -224,12 +225,72 @@
   }
 
   // 활성 런타임이 중립 이름으로 소비하는 정규화 진입점: 어떤 등록 모양이든 v2 data를 돌려준다.
+  // Explicit, reviewed migration only. Rendering and ordinary saves never call this.
+  function convertToEventTimeline(data) {
+    if (detectShape(data) !== "v2") throw new Error("시간 그룹 이관은 timeLevels/entries 원본만 지원합니다.");
+    if (data.entries.some(entry => entry.lane.kind === "unresolved")) throw new Error("미연결 캐릭터를 먼저 해결해 주세요.");
+    const places = JSON.parse(JSON.stringify(data.places || []));
+    const groups = data.timeLevels.map(level => ({ id: level.id, name: level.name, type: level.mode === "clock" ? "timeline" : "text" }));
+    const events = data.entries.map(entry => {
+      const group = groups.find(group => group.id === entry.timeLevelId);
+      if (!group) throw new Error("존재하지 않는 시간 그룹입니다.");
+      const ids = entry.placeIds || [];
+      const matched = places.find(place => place.name.trim() === text(entry.location).trim());
+      const placeId = ids.at(-1) || matched?.id || null;
+      const annotations = [];
+      const location = text(entry.location).trim();
+      if (ids.length > 1) annotations.push(`기존 이동 경로: ${entryPlaceNames(data, entry).join(" → ")}`);
+      if (location && ![places.find(place => place.id === placeId)?.name, entryPlaceNames(data, entry).join(" → ")].includes(location)) annotations.push(`기존 장소 메모: ${location}`);
+      if (!ids.length && !matched && location && !annotations.some(value => value.endsWith(location))) annotations.push(`기존 장소 메모: ${location}`);
+      const event = { id: entry.id, timeGroupId: entry.timeLevelId, description: entry.text, characterId: entry.lane.kind === "character" ? entry.lane.characterId : null, placeId };
+      if (entry.included === false) event.included = false;
+      if (group.type === "timeline") {
+        if (entry.when.kind !== "clock") throw new Error("시각이 없는 사건의 시간 범위를 먼저 지정해 주세요.");
+        const start = (entry.when.dayOffset || 0) * 1440 + entry.when.startMinute;
+        const end = entry.when.endMinute === undefined ? start + 30 : (entry.when.dayOffset || 0) * 1440 + entry.when.endMinute;
+        if (end <= start) throw new Error("시작 이후의 종료 시간을 지정해 주세요.");
+        event.timeRange = { start: minutePoint(start), end: minutePoint(end) };
+        const clockLabel = minute => `${String(Math.floor(minute / 60)).padStart(2, "0")}:${String(minute % 60).padStart(2, "0")}`;
+        const canonical = clockLabel(entry.when.startMinute) + (entry.when.endMinute === undefined ? "" : `~${clockLabel(entry.when.endMinute)}`);
+        const normalized = text(entry.timeLabel).replace(/[–—−-]/g, "~").replace(/\s/g, "");
+        if (normalized && normalized !== canonical) annotations.push(`기존 시간 표현: ${entry.timeLabel}`);
+      } else if (text(entry.timeLabel).trim()) annotations.push(`기존 시간 표현: ${entry.timeLabel}`);
+      if (annotations.length) event.description += `${event.description ? "\n\n" : ""}${annotations.join("\n")}`;
+      return event;
+    });
+    return { timeGroups: groups, events, places };
+  }
+
+  function pointMinutes(point) { return point.day * 1440 + point.hour * 60 + point.minute; }
+  function minutePoint(value) { return { day: Math.floor(value / 1440), hour: Math.floor(value % 1440 / 60), minute: value % 60 }; }
+  function defaultRange(start = { day: 0, hour: 9, minute: 0 }) { return { start: { ...start }, end: minutePoint(pointMinutes(start) + 30) }; }
+  function pointLabel(point) { return `${point.day + 1}일차 ${String(point.hour).padStart(2, "0")}:${String(point.minute).padStart(2, "0")}`; }
+  function rangeLabel(range) { return range ? `${pointLabel(range.start)}–${pointLabel(range.end)}` : ""; }
+  function orderedEvents(data) {
+    const groups = new Map(data.timeGroups.map((group, index) => [group.id, { ...group, index }]));
+    return data.events.map((event, index) => ({ event, index })).sort((a, b) => {
+      const ga = groups.get(a.event.timeGroupId), gb = groups.get(b.event.timeGroupId);
+      return ga.index - gb.index || (ga.type === "timeline" ? pointMinutes(a.event.timeRange.start) - pointMinutes(b.event.timeRange.start) : 0) || a.index - b.index;
+    }).map(item => item.event);
+  }
+  // Projection only: old board/output consumers never own this derived representation.
+  function eventTimelineProjection(data) {
+    return { timeLevels: data.timeGroups.map(group => ({ id: group.id, name: group.name, mode: group.type === "timeline" ? "clock" : "manual" })), places: data.places,
+      entries: orderedEvents(data).map(event => ({ id: event.id, timeLevelId: event.timeGroupId,
+        lane: event.characterId === null ? { kind: "truth" } : { kind: "character", characterId: event.characterId },
+        when: event.timeRange ? { kind: "clock", dayOffset: event.timeRange.start.day, startMinute: event.timeRange.start.hour * 60 + event.timeRange.start.minute,
+          endMinute: pointMinutes(event.timeRange.end) - event.timeRange.start.day * 1440 } : { kind: "unspecified" },
+        timeLabel: rangeLabel(event.timeRange), text: event.description, included: event.included !== false,
+        placeIds: event.placeId === null ? [] : [event.placeId], location: "" })) };
+  }
+
   function normalizedTimelineData(data, options = {}) {
+    if (detectShape(data) === "events") return eventTimelineProjection(data);
     const shape = detectShape(data);
     if (shape === "v2") return data;
     if (shape === "legacy") return convertLegacyTimeline(data, options);
     throw new Error("타임라인 data가 등록된 모양이 아닙니다.");
   }
 
-  return Object.freeze({ detectShape, convertLegacyTimeline, compareLegacyToV2, normalizedTimelineData, entryPlaceNames, orderedEntries, overlapGroups, deriveClusters });
+  return Object.freeze({ convertToEventTimeline, pointMinutes, minutePoint, defaultRange, pointLabel, rangeLabel, orderedEvents, eventTimelineProjection, detectShape, convertLegacyTimeline, compareLegacyToV2, normalizedTimelineData, entryPlaceNames, orderedEntries, overlapGroups, deriveClusters });
 });

package/tools/writer-cli/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@ssobig/writer-cli",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ssobig/writer-cli",
-      "version": "0.3.2",
+      "version": "0.3.4",
       "dependencies": {
         "@supabase/supabase-js": "2.110.9"
       },

package/tools/writer-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ssobig/writer-cli",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "private": true,
   "description": "Internal agent-safe CLI for SSOBIG WRITER manuscript and asset operations",
   "type": "commonjs",