@ssobig/writer-cli 0.2.0

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

@@ -0,0 +1,205 @@
+(function (root, factory) {
+  let contract = root && root.WriterWorkbenchComponentContract;
+  let fieldContracts = root && root.WriterWorkbenchComponentFieldContracts;
+  let catalogContract = root && root.WriterWorkbenchComponentCatalogContract;
+  if (typeof module === "object" && module.exports) {
+    contract = require("./component-contract.js");
+    fieldContracts = require("./component-field-contracts.js");
+    catalogContract = require("./component-catalog-contract.js");
+  }
+  const api = factory(contract, fieldContracts, catalogContract);
+  if (typeof module === "object" && module.exports) module.exports = api;
+  if (root) root.WriterWorkbenchComponentRegistry = api;
+})(typeof globalThis !== "undefined" ? globalThis : this, function (contract, fieldContracts, catalogContract) {
+  "use strict";
+
+  if (!contract) throw new Error("WriterWorkbenchComponentContract is required");
+  if (!fieldContracts) throw new Error("WriterWorkbenchComponentFieldContracts is required");
+  if (!catalogContract) throw new Error("WriterWorkbenchComponentCatalogContract is required");
+
+  const { WORKSPACE_MODES, normalizeVariantId, assertVariantId } = contract;
+
+  function deepFreeze(value) {
+    if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+    Object.values(value).forEach(deepFreeze);
+    return Object.freeze(value);
+  }
+
+  function clonePlain(value) {
+    if (Array.isArray(value)) return value.map(clonePlain);
+    if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clonePlain(item)]));
+    return value;
+  }
+
+  function view(id, label, kind = id, options = {}) {
+    return Object.freeze({ id, label, kind, implemented: options.implemented !== false, description: String(options.description || "") });
+  }
+
+  const genericDesignViews = Object.freeze([view("theme", "테마", "design")]);
+  const genericValidationViews = Object.freeze([view("schema", "구조 검사", "validation")]);
+  const directAuthoring = Object.freeze([view("json", "직접 JSON", "json")]);
+  const rawPreview = Object.freeze([view("raw", "원본 데이터", "json")]);
+
+  const CLUE_FIELD_CONFIGURATION = deepFreeze([
+    { key: "name", label: "단서 이름", required: true, description: "단서를 구분하는 표시 이름" },
+    { key: "title", label: "단서 제목", required: true, description: "단서 카드에 표시하는 제목" },
+    { key: "description", label: "설명", required: true, description: "플레이어가 읽는 단서 내용" },
+    { key: "confirmed", label: "확정 여부", description: "확정된 단서만 미리보기에 표시" },
+    { key: "image", label: "이미지", description: "단서 이미지 등록과 미리보기" },
+    { key: "location", label: "위치", description: "단서를 발견하거나 사용하는 위치" },
+    { key: "tags", label: "태그", description: "단서 분류와 미리보기 필터" },
+    { key: "color", label: "컬러", description: "단서 분류용 대표 색상" },
+    { key: "secret", label: "작가 노트", description: "제작자만 확인하는 단서 메모" }
+  ]);
+
+  const BASIC_FIELD_CONFIGURATION = deepFreeze([
+    { key: "title", label: "작품 제목", required: true, description: "작품을 구분하고 상세 화면에 표시하는 제목" },
+    { key: "playerCount", label: "플레이 인원", required: true, description: "최소·최대 플레이 인원" },
+    { key: "intro", label: "2줄 소개", required: true, description: "작품을 짧게 소개하는 문구" },
+    { key: "detail", label: "상세 페이지", required: true, description: "작품의 상세 소개와 안내" },
+    { key: "theme", label: "화면 모드", required: true, description: "라이트 또는 다크 화면 설정" },
+    { key: "font", label: "폰트", required: true, description: "워크벤치와 미리보기에 사용할 글꼴" },
+    { key: "poster", label: "포스터 이미지", required: true, description: "작품 상세 화면의 대표 이미지" },
+    { key: "logo", label: "로고 이미지", required: true, description: "작품 상세 화면의 로고" },
+    { key: "workspace-background", label: "배경 이미지", required: true, description: "제작 화면과 미리보기의 배경 이미지" },
+    { key: "brandColor", label: "브랜드 컬러", required: true, description: "작품의 강조 영역에 사용하는 색상" },
+    { key: "backgroundColor", label: "배경 컬러", required: true, description: "제작 화면과 미리보기의 기본 배경색" }
+  ]);
+
+  const CHARACTER_FIELD_CONFIGURATION = deepFreeze([
+    { key: "name", label: "캐릭터 이름", required: true, description: "캐릭터를 구분하는 표시 이름" },
+    { key: "isPlayable", label: "플레이어 캐릭터", required: true, description: "플레이어가 맡는 캐릭터인지 NPC인지 구분" },
+    { key: "customSections", label: "캐릭터 원고", required: true, description: "Container에 자유롭게 배치하는 제목과 본문" },
+    { 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: "연기 방향과 설계 의도 메모" }
+  ]);
+
+  function template(input) {
+    return {
+      templateId: input.templateId,
+      defaultInstanceId: input.defaultInstanceId || input.templateId.split(".").at(-1),
+      name: input.name,
+      description: input.description || "",
+      dataSchema: fieldContracts.jsonSchemaFor(input.templateId),
+      required: input.required === true,
+      removable: input.required !== true,
+      allowMultiple: input.allowMultiple === true,
+      internal: input.internal === true,
+      guide: clonePlain(input.guide || {}),
+      fieldConfiguration: input.fieldConfiguration || [],
+      views: {
+        [WORKSPACE_MODES.AUTHORING]: input.authoring || directAuthoring,
+        [WORKSPACE_MODES.PREVIEW]: input.preview || rawPreview,
+        [WORKSPACE_MODES.DESIGN]: input.design || genericDesignViews,
+        [WORKSPACE_MODES.VALIDATION]: input.validation || genericValidationViews
+      },
+      defaultViews: {
+        [WORKSPACE_MODES.AUTHORING]: (input.authoring || directAuthoring)[0]?.id || null,
+        [WORKSPACE_MODES.PREVIEW]: (input.preview || rawPreview)[0]?.id || null,
+        [WORKSPACE_MODES.DESIGN]: (input.design || genericDesignViews)[0]?.id || null,
+        [WORKSPACE_MODES.VALIDATION]: (input.validation || genericValidationViews)[0]?.id || null
+      }
+    };
+  }
+
+  const FIELD_CONFIGURATION = Object.freeze({
+    "ssobig.basic": BASIC_FIELD_CONFIGURATION,
+    "ssobig.character": CHARACTER_FIELD_CONFIGURATION,
+    "ssobig.clues": CLUE_FIELD_CONFIGURATION
+  });
+
+  const INITIAL_TEMPLATE_CATALOG = deepFreeze(catalogContract.list().map(descriptor => template({
+    templateId: descriptor.templateId,
+    name: descriptor.tabLabel,
+    required: descriptor.required,
+    internal: descriptor.internal,
+    allowMultiple: descriptor.allowMultiple,
+    defaultInstanceId: descriptor.defaultInstanceId,
+    description: descriptor.description,
+    guide: descriptor.guide,
+    fieldConfiguration: FIELD_CONFIGURATION[descriptor.templateId] || []
+  })));
+
+  function normalizeTemplate(input) {
+    if (!input || typeof input !== "object") throw new TypeError("Component template must be an object");
+    const templateId = String(input.templateId || "").trim();
+    if (!/^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/.test(templateId)) throw new TypeError(`Invalid component template ID: ${templateId}`);
+    const schema = input.dataSchema || fieldContracts.jsonSchemaFor(templateId);
+    if (!schema) throw new TypeError(`Component data schema is not registered: ${templateId}`);
+    const views = {};
+    const defaultViews = {};
+    [WORKSPACE_MODES.AUTHORING, WORKSPACE_MODES.PREVIEW, WORKSPACE_MODES.DESIGN, WORKSPACE_MODES.VALIDATION].forEach(mode => {
+      const seen = new Set();
+      views[mode] = (Array.isArray(input.views?.[mode]) ? input.views[mode] : []).map(item => {
+        const source = typeof item === "string" ? { id: item, label: item } : item || {};
+        const id = assertVariantId(normalizeVariantId(source.id, null), `${templateId}.${mode}.view.id`);
+        if (seen.has(id)) throw new Error(`Duplicate ${mode} view '${id}' in ${templateId}`);
+        seen.add(id);
+        return { id, label: String(source.label || id), kind: String(source.kind || id), implemented: source.implemented !== false, description: String(source.description || "") };
+      });
+      const requestedDefault = input.defaultViews?.[mode];
+      const defaultId = requestedDefault == null ? views[mode][0]?.id || null : normalizeVariantId(requestedDefault, null);
+      if (defaultId && !seen.has(defaultId)) throw new Error(`Default ${mode} view '${defaultId}' is not registered in ${templateId}`);
+      defaultViews[mode] = defaultId;
+    });
+    const defaultInstanceId = String(input.defaultInstanceId || templateId.split(".").at(-1));
+    if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(defaultInstanceId)) throw new TypeError(`Invalid default instance ID for ${templateId}`);
+    return deepFreeze({
+      templateId,
+      defaultInstanceId,
+      name: String(input.name || templateId),
+      description: String(input.description || ""),
+      dataSchema: clonePlain(schema),
+      required: input.required === true,
+      removable: input.required === true ? false : input.removable !== false,
+      allowMultiple: input.allowMultiple === true,
+      internal: input.internal === true,
+      guide: clonePlain(input.guide || {}),
+      fieldConfiguration: (Array.isArray(input.fieldConfiguration) ? input.fieldConfiguration : []).map(item => ({
+        key: String(item?.key || ""), label: String(item?.label || item?.key || ""), description: String(item?.description || ""), required: item?.required === true
+      })),
+      views,
+      defaultViews
+    });
+  }
+
+  function createRegistry(initialTemplates = INITIAL_TEMPLATE_CATALOG) {
+    const templates = new Map();
+
+    function register(input, options = {}) {
+      const normalized = normalizeTemplate(input);
+      if (templates.has(normalized.templateId) && options.replace !== true) throw new Error(`Component template already registered: ${normalized.templateId}`);
+      templates.set(normalized.templateId, normalized);
+      return normalized;
+    }
+
+    function get(templateId) {
+      return templates.get(String(templateId || "").trim()) || null;
+    }
+
+    function canInstantiate(templateId, instances = []) {
+      const selected = get(templateId);
+      if (!selected) return false;
+      return selected.allowMultiple || !instances.some(instance => instance?.templateId === selected.templateId);
+    }
+
+    initialTemplates.forEach(item => register(item));
+    return Object.freeze({
+      register,
+      get,
+      has: id => Boolean(get(id)),
+      canInstantiate,
+      list: () => [...templates.values()].sort((left, right) => left.templateId.localeCompare(right.templateId))
+    });
+  }
+
+  return Object.freeze({
+    INITIAL_TEMPLATE_CATALOG,
+    normalizeTemplate,
+    createRegistry,
+    createDefaultRegistry: () => createRegistry(INITIAL_TEMPLATE_CATALOG)
+  });
+});

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

@@ -0,0 +1,139 @@
+(function (root, factory) {
+  let dependencies = root ? {
+    appearance: root.WriterWorkbenchAppearance,
+    shared: root.WriterWorkbenchRendererShared,
+    basic: root.WriterWorkbenchBasicRenderer,
+    common: root.WriterWorkbenchCommonRenderer,
+    character: root.WriterWorkbenchCharacterRenderer,
+    clues: root.WriterWorkbenchCluesRenderer,
+    clueCombinations: root.WriterWorkbenchClueCombinationsRenderer,
+    aiResponse: root.WriterWorkbenchAiResponseRenderer,
+    timeline: root.WriterWorkbenchTimelineRenderer,
+    ending: root.WriterWorkbenchEndingRenderer,
+    postgame: root.WriterWorkbenchPostgameRenderer,
+    authorNotes: root.WriterWorkbenchAuthorNotesRenderer,
+    investigationBoard: root.WriterWorkbenchInvestigationBoardRenderer,
+    documents: root.WriterWorkbenchDocumentRenderers
+  } : {};
+  if (typeof module === "object" && module.exports) dependencies = {
+    appearance: require("./renderers/appearance.js"),
+    shared: require("./renderers/shared.js"),
+    basic: require("./renderers/basic.js"),
+    common: require("./renderers/common.js"),
+    character: require("./renderers/character.js"),
+    clues: require("./renderers/clues.js"),
+    clueCombinations: require("./renderers/clue-combinations.js"),
+    aiResponse: require("./renderers/ai-response.js"),
+    timeline: require("./renderers/timeline.js"),
+    ending: require("./renderers/ending.js"),
+    postgame: require("./renderers/postgame.js"),
+    authorNotes: require("./renderers/author-notes.js"),
+    investigationBoard: require("./renderers/investigation-board.js"),
+    documents: require("./renderers/documents.js")
+  };
+  const api = factory(dependencies);
+  if (typeof module === "object" && module.exports) module.exports = api;
+  if (root) root.WriterWorkbenchComponentRenderers = api;
+})(typeof globalThis !== "undefined" ? globalThis : this, function (dependencies) {
+  "use strict";
+  const { appearance, shared, basic, common, character, clues, clueCombinations, aiResponse, timeline, ending, postgame, authorNotes, investigationBoard, documents } = dependencies;
+  if (!appearance || !shared || !basic || !common || !character || !clues || !clueCombinations || !aiResponse || !timeline || !ending || !postgame || !authorNotes || !investigationBoard || !documents) throw new Error("Component renderer modules are incomplete");
+
+  const renderers = new Map();
+  function register(renderer) {
+    const key = String(renderer.templateId || "");
+    if (renderers.has(key)) throw new Error(`중복 Component 렌더러입니다: ${key}`);
+    renderers.set(key, Object.freeze({ ...renderer }));
+  }
+  [basic, common, { ...common, templateId: "ssobig.choice" }, character, clues, clueCombinations, aiResponse, timeline, ending, postgame, authorNotes, investigationBoard].forEach(register);
+  Object.entries(documents.definitions).forEach(([templateId, definition]) => register({
+    templateId,
+    renderAuthoring: documents.renderAuthoring,
+    renderPreview: documents.renderPreview,
+    bind: documents.bind
+  }));
+
+  function resolve(instance) {
+    const key = String(instance?.templateId || "");
+    const renderer = renderers.get(key);
+    if (!renderer) throw new Error(`지원되지 않는 Component 렌더러입니다: ${key}`);
+    return renderer;
+  }
+  function resolveView(viewModel) {
+    const view = viewModel?.view;
+    const primary = viewModel?.primary;
+    if (!view || !primary?.instance || view.rendererId !== primary.instance.templateId) {
+      throw new Error("View Component renderer binding이 올바르지 않습니다.");
+    }
+    const key = view.rendererId;
+    const renderer = renderers.get(key);
+    if (!renderer) throw new Error(`지원되지 않는 View Component 렌더러입니다: ${key}`);
+    return renderer;
+  }
+  function defaultView() { return "preview"; }
+  function context(instance, data, extra = {}) {
+    return { instance, data, ...extra, view: shared.rendererView(extra, defaultView(instance)) };
+  }
+  function viewContext(viewModel, extra = {}) {
+    const primary = viewModel?.primary;
+    return {
+      ...extra,
+      viewComponent: viewModel.view,
+      bindings: viewModel.bindings,
+      instance: primary.instance,
+      data: primary.data,
+      view: shared.rendererView(extra, defaultView(primary.instance))
+    };
+  }
+  function applyRendererView(markup, view) {
+    return String(markup)
+      .replace(/data-renderer-view="(?:input|preview)"/, `data-renderer-view="${view}"`);
+  }
+  function renderAuthoring(instance, data, extra) {
+    const rendererContext = context(instance, data, extra);
+    return applyRendererView(resolve(instance).renderAuthoring(rendererContext), rendererContext.view);
+  }
+  function renderPreview(instance, data = instance?.data, extra) { return resolve(instance).renderPreview(context(instance, data, extra)); }
+  function bind(instance, root, data, extra) {
+    const renderer = resolve(instance);
+    const rendererContext = context(instance, data, extra);
+    rendererContext.renderPreview = () => renderer.renderPreview(rendererContext);
+    return typeof renderer.bind === "function" ? renderer.bind(root, rendererContext) : () => {};
+  }
+  function renderAuthoringView(viewModel, extra) {
+    const renderer = resolveView(viewModel);
+    const rendererContext = viewContext(viewModel, extra);
+    return applyRendererView(renderer.renderAuthoring(rendererContext), rendererContext.view);
+  }
+  function renderPreviewView(viewModel, extra) {
+    return resolveView(viewModel).renderPreview(viewContext(viewModel, extra));
+  }
+  function bindView(viewModel, root, extra) {
+    const renderer = resolveView(viewModel);
+    const rendererContext = viewContext(viewModel, extra);
+    rendererContext.renderPreview = () => renderer.renderPreview(rendererContext);
+    return typeof renderer.bind === "function" ? renderer.bind(root, rendererContext) : () => {};
+  }
+
+  return Object.freeze({
+    resolve,
+    resolveView,
+    defaultView,
+    renderAuthoring,
+    renderPreview,
+    bind,
+    renderAuthoringView,
+    renderPreviewView,
+    bindView,
+    list: () => [...renderers.keys()],
+    clone: shared.clone,
+    inlineText: shared.inlineText,
+    formattedText: shared.formattedText,
+    pathToken: shared.pathToken,
+    decodePath: shared.decodePath,
+    escapeHtml: shared.escapeHtml,
+    clueAssetId: clues.clueAssetId,
+    setProgressPreviewMode: documents.setProgressPreviewMode,
+    appearance
+  });
+});

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

@@ -0,0 +1,237 @@
+(function (root, factory) {
+  let fieldContracts = root && root.WriterWorkbenchComponentFieldContracts;
+  let catalogContract = root && root.WriterWorkbenchComponentCatalogContract;
+  if (typeof module === "object" && module.exports) {
+    fieldContracts = require("./component-field-contracts.js");
+    catalogContract = require("./component-catalog-contract.js");
+  }
+  const api = factory(fieldContracts, catalogContract);
+  if (typeof module === "object" && module.exports) module.exports = api;
+  if (root) root.WriterWorkbenchComponentStorageContract = api;
+})(typeof globalThis !== "undefined" ? globalThis : this, function (fieldContracts, catalogContract) {
+  "use strict";
+  if (!fieldContracts) throw new Error("WriterWorkbenchComponentFieldContracts is required");
+  if (!catalogContract) throw new Error("WriterWorkbenchComponentCatalogContract is required");
+
+  const MANIFEST_SCHEMA_VERSION = "project-component-manifest-v1";
+  const COMPONENT_SPECS = Object.freeze(catalogContract.list().map(descriptor => spec(descriptor.templateId, descriptor)));
+  const COMPONENT_BY_ID = new Map(COMPONENT_SPECS.map(component => [component.templateId, component]));
+  const REQUIRED_COMPONENTS = Object.freeze(COMPONENT_SPECS.filter(component => component.required));
+  const REMOVED_VERSION_FIELDS = Object.freeze(["template_version", "state_schema_version", "templateVersion", "stateSchemaVersion"]);
+
+  function spec(templateId, options = {}) {
+    return Object.freeze({
+      templateId,
+      required: options.required === true,
+      internal: options.internal === true,
+      allowMultiple: options.allowMultiple === true,
+      editorViews: Object.freeze(["json"]),
+      previewViews: Object.freeze(["raw"]),
+      validate: data => fieldContracts.validateTargetData(templateId, data)
+    });
+  }
+
+  function isObject(value) { return Boolean(value && typeof value === "object" && !Array.isArray(value)); }
+  function clone(value) {
+    if (value === null || ["string", "number", "boolean"].includes(typeof value)) return value;
+    if (Array.isArray(value)) return value.map(clone);
+    if (isObject(value)) return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clone(item)]));
+    return null;
+  }
+  function failure(code, message) { const error = new Error(message); error.code = code; return { ok: false, error }; }
+  function contractError(code, message) { const error = new Error(message); error.code = code; return error; }
+  function componentSpec(templateId) { return COMPONENT_BY_ID.get(String(templateId || "")) || null; }
+
+  function containsAssetPointerField(value) {
+    if (Array.isArray(value)) return value.some(containsAssetPointerField);
+    if (!isObject(value)) return false;
+    return Object.entries(value).some(([key, item]) => {
+      const normalizedKey = key.replace(/[_-]/g, "").toLowerCase();
+      if (["image", "imageurl", "imageurls", "imagepath", "imagepaths", "imagefilename", "filename", "filepath", "fileurl"].some(suffix => normalizedKey.endsWith(suffix))) return true;
+      return containsAssetPointerField(item);
+    });
+  }
+
+  function validateComponentData(component, data) {
+    return component.validate(data)
+      || (!component.internal && containsAssetPointerField(data) ? "파일 pointer는 ssobig.assets Component만 소유할 수 있습니다." : null);
+  }
+
+  function normalizeViewId(value) { return value == null ? null : typeof value === "string" && /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(value) ? value : null; }
+  function normalizeViewSelection(capabilities, editorViewId, previewViewId) {
+    const views = isObject(capabilities?.viewSelection) ? clone(capabilities.viewSelection) : {};
+    if (editorViewId !== null) views.authoring = editorViewId;
+    if (previewViewId !== null) views.preview = previewViewId;
+    return views;
+  }
+  function validViewSelection(value) {
+    return isObject(value) && Object.entries(value).every(([mode, viewId]) => ["authoring", "preview", "design", "validation"].includes(mode)
+      && (viewId === null || (typeof viewId === "string" && /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(viewId))));
+  }
+
+  function normalizeInstance(instance) {
+    if (!isObject(instance)
+      || REMOVED_VERSION_FIELDS.some(field => Object.hasOwn(instance, field))
+      || typeof instance.instance_id !== "string" || !/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(instance.instance_id)
+      || typeof instance.template_id !== "string" || !/^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/.test(instance.template_id)
+      || !Number.isSafeInteger(instance.sort_order) || instance.sort_order < 0
+      || !Number.isSafeInteger(instance.revision) || instance.revision < 1
+      || typeof instance.tab_label !== "string" || !instance.tab_label.trim() || instance.tab_label.length > 120
+      || typeof instance.is_enabled !== "boolean" || typeof instance.is_archived !== "boolean"
+      || typeof instance.is_required !== "boolean" || typeof instance.is_removable !== "boolean"
+      || !isObject(instance.capabilities) || !isObject(instance.config) || !isObject(instance.data)) return null;
+    if (!componentSpec(instance.template_id)) return null;
+    const editorViewId = normalizeViewId(instance.editor_view_id);
+    const previewViewId = normalizeViewId(instance.preview_view_id);
+    if ((instance.editor_view_id != null && editorViewId === null) || (instance.preview_view_id != null && previewViewId === null)
+      || (Object.hasOwn(instance.capabilities, "viewSelection") && !validViewSelection(instance.capabilities.viewSelection))) return null;
+    const capabilities = clone(instance.capabilities);
+    return {
+      instanceId: instance.instance_id,
+      templateId: instance.template_id,
+      tab: instance.tab_label,
+      order: instance.sort_order,
+      enabled: instance.is_enabled,
+      archived: instance.is_archived,
+      required: instance.is_required,
+      removable: instance.is_removable,
+      editorViewId,
+      previewViewId,
+      capabilities,
+      viewSelection: normalizeViewSelection(capabilities, editorViewId, previewViewId),
+      config: clone(instance.config),
+      data: clone(instance.data),
+      revision: instance.revision
+    };
+  }
+
+  function runtimeInstance(instance) { return instance.enabled && !instance.archived; }
+  function validateViewId(value, allowed, label) { return value === null || allowed.includes(value) ? null : `${label} 보기(${value})는 이 Component에서 지원되지 않습니다.`; }
+  function validateRuntimeInstance(instance) {
+    const component = componentSpec(instance.templateId);
+    if (!component) return `지원되지 않는 Component(${instance.templateId})입니다.`;
+    const configKeys = Object.keys(instance.config);
+    if (component.internal ? configKeys.some(key => key !== "hidden") : configKeys.length > 0) return `${instance.templateId} config에 지원되지 않는 필드가 있습니다.`;
+    const editorError = validateViewId(instance.editorViewId, component.editorViews, "편집");
+    const previewError = validateViewId(instance.previewViewId, component.previewViews, "미리보기");
+    const selectedAuthoringError = validateViewId(instance.viewSelection.authoring ?? null, component.editorViews, "저장된 편집");
+    const selectedPreviewError = validateViewId(instance.viewSelection.preview ?? null, component.previewViews, "저장된 미리보기");
+    const designError = validateViewId(instance.viewSelection.design ?? null, ["theme"], "저장된 디자인");
+    const validationError = validateViewId(instance.viewSelection.validation ?? null, ["schema"], "저장된 검증");
+    return editorError || previewError || selectedAuthoringError || selectedPreviewError || designError || validationError
+      || validateComponentData(component, instance.data)
+      || (component.internal && instance.config?.hidden !== true ? "에셋 Component는 내부 전용으로 숨김 처리되어야 합니다." : null);
+  }
+
+  function compositionRelationError(instances) {
+    const character = instances.find(instance => instance.templateId === "ssobig.character");
+    if (character) {
+      const characterIds = new Set(Object.keys(character.data.characters || {}));
+      for (const timeline of instances.filter(instance => instance.templateId === "ssobig.timeline")) {
+        for (const event of timeline.data.events) {
+          const missing = Object.keys(event.memories).find(id => !characterIds.has(id));
+          if (missing) return `${timeline.instanceId} timeline memory가 존재하지 않는 character(${missing})를 가리킵니다.`;
+          const unassigned = Object.keys(event.unassignedMemories || {});
+          const assigned = unassigned.find(id => characterIds.has(id));
+          if (assigned) return `${timeline.instanceId} unassigned memory(${assigned})는 현재 character에 연결할 수 있습니다.`;
+          const overlap = unassigned.find(id => Object.hasOwn(event.memories, id));
+          if (overlap) return `${timeline.instanceId} memory(${overlap})가 assigned와 unassigned에 중복 저장되어 있습니다.`;
+        }
+      }
+    }
+    const clues = instances.find(instance => instance.templateId === "ssobig.clues");
+    for (const combinations of instances.filter(instance => instance.templateId === "ssobig.clue-combinations")) {
+      if (!clues) return `${combinations.instanceId} 단서 조합에는 ssobig.clues 문맥이 필요합니다.`;
+      const clueIds = new Set(clues.data.clues.map(clue => String(clue.id).toLowerCase()));
+      for (const combination of combinations.data.combinations) {
+        const missing = [...combination.conditions, ...combination.results]
+          .filter(item => item.kind === "clue")
+          .map(item => String(item.clueId).toLowerCase())
+          .find(id => !clueIds.has(id));
+        if (missing) return `${combinations.instanceId} 단서 조합이 존재하지 않는 clue(${missing})를 가리킵니다.`;
+      }
+    }
+    return null;
+  }
+
+  function validateActiveComponentSet(componentSet) {
+    if (String(componentSet?.canonical_status || "") !== "active") return failure("SOMI_MIGRATION_REQUIRED", "이 작품은 Component 이관이 아직 완료되지 않았습니다.");
+    if (!Number.isSafeInteger(componentSet?.version_number) || componentSet.version_number < 1 || !Number.isSafeInteger(componentSet?.revision) || componentSet.revision < 1) return failure("SOMI_MIGRATION_REQUIRED", "활성 Component Set 식별자나 revision이 올바르지 않습니다.");
+    if (!String(componentSet?.component_checksum || "").trim()) return failure("SOMI_MIGRATION_REQUIRED", "활성 Component 구성의 검증값이 없습니다. 이관 검증이 필요합니다.");
+    return null;
+  }
+  function validRuntimeInstanceShape(instance) {
+    return isObject(instance)
+      && REMOVED_VERSION_FIELDS.every(field => !Object.hasOwn(instance, field))
+      && typeof instance.instanceId === "string" && /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(instance.instanceId)
+      && typeof instance.templateId === "string" && /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/.test(instance.templateId)
+      && Number.isSafeInteger(instance.order) && instance.order >= 0
+      && Number.isSafeInteger(instance.revision) && instance.revision >= 1
+      && typeof instance.tab === "string" && Boolean(instance.tab.trim()) && instance.tab.length <= 120
+      && typeof instance.enabled === "boolean" && typeof instance.archived === "boolean"
+      && typeof instance.required === "boolean" && typeof instance.removable === "boolean"
+      && isObject(instance.capabilities) && isObject(instance.viewSelection) && isObject(instance.config) && isObject(instance.data);
+  }
+  function validateRuntimeComposition(componentSet, instances) {
+    const setError = validateActiveComponentSet(componentSet);
+    if (setError) return setError;
+    if (!Array.isArray(instances) || !instances.length) return failure("SOMI_MIGRATION_REQUIRED", "활성화된 Component가 없습니다. 이관 검증이 필요합니다.");
+    if (instances.some(instance => !validRuntimeInstanceShape(instance) || !runtimeInstance(instance))) return failure("SOMI_MIGRATION_REQUIRED", "활성 Component 런타임 데이터 형식이 완전하지 않습니다. 이관 검증이 필요합니다.");
+    const activeInstances = [...instances].sort((left, right) => left.order - right.order);
+    if (new Set(activeInstances.map(instance => instance.instanceId)).size !== activeInstances.length || new Set(activeInstances.map(instance => instance.order)).size !== activeInstances.length) return failure("SOMI_MIGRATION_REQUIRED", "활성 Component 식별자 또는 순서가 중복되었습니다.");
+    for (const instance of activeInstances) { const invalid = validateRuntimeInstance(instance); if (invalid) return failure("SOMI_MIGRATION_REQUIRED", `${invalid} 이관 검증이 필요합니다.`); }
+    const relationError = compositionRelationError(activeInstances);
+    if (relationError) return failure("SOMI_MIGRATION_REQUIRED", `${relationError} 이관 검증이 필요합니다.`);
+    for (const templateId of new Set(REQUIRED_COMPONENTS.map(component => component.templateId))) {
+      const matches = activeInstances.filter(instance => instance.templateId === templateId);
+      if (matches.length !== 1 || !matches[0].required || matches[0].removable !== false) return failure("SOMI_MIGRATION_REQUIRED", `필수 Component(${templateId})가 완전하지 않습니다. 이관 검증이 필요합니다.`);
+    }
+    const singletonTemplateIds = new Set(COMPONENT_SPECS.filter(item => !item.allowMultiple).map(item => item.templateId));
+    for (const templateId of singletonTemplateIds) if (activeInstances.filter(instance => instance.templateId === templateId).length > 1) return failure("SOMI_MIGRATION_REQUIRED", `${templateId} Component가 중복되어 있습니다. 이관 검증이 필요합니다.`);
+    return { ok: true, instances: activeInstances };
+  }
+  function validateActiveComposition(componentSet, rows) {
+    const setError = validateActiveComponentSet(componentSet);
+    if (setError) return setError;
+    if (!Array.isArray(rows) || !rows.length) return failure("SOMI_MIGRATION_REQUIRED", "저장된 Component가 없습니다. 이 작품은 이관이 필요합니다.");
+    if (rows.some(row => !isObject(row) || typeof row.is_enabled !== "boolean" || typeof row.is_archived !== "boolean")) return failure("SOMI_MIGRATION_REQUIRED", "Component 활성 상태가 완전하지 않습니다. 이관 검증이 필요합니다.");
+    const activeRows = rows.filter(row => row.is_enabled && !row.is_archived);
+    const instances = activeRows.map(normalizeInstance).filter(Boolean).sort((left, right) => left.order - right.order);
+    if (instances.length !== activeRows.length) return failure("SOMI_MIGRATION_REQUIRED", "활성 Component 데이터 형식이 완전하지 않습니다. 이관 검증이 필요합니다.");
+    return validateRuntimeComposition(componentSet, instances);
+  }
+  function archivedInstances(rows) {
+    if (!Array.isArray(rows)) return [];
+    return rows.filter(row => row?.is_archived === true || row?.is_enabled === false)
+      .map(normalizeInstance)
+      .filter(instance => instance && !instance.required && instance.removable && validateRuntimeInstance(instance) === null)
+      .sort((left, right) => left.order - right.order);
+  }
+  function manifest(project, instances, views = []) {
+    const title = String(instances.find(instance => runtimeInstance(instance) && instance.templateId === "ssobig.basic")?.data?.title || "");
+    return {
+      schemaVersion: MANIFEST_SCHEMA_VERSION,
+      project: { id: String(project?.id || ""), title },
+      components: instances.map(instance => ({ instanceId: instance.instanceId, templateId: instance.templateId, tab: instance.tab, order: instance.order, enabled: instance.enabled, archived: instance.archived, required: instance.required, removable: instance.removable, editorViewId: instance.editorViewId, previewViewId: instance.previewViewId, viewSelection: clone(instance.viewSelection), capabilities: clone(instance.capabilities), config: clone(instance.config) })),
+      views: views.map(view => ({ viewInstanceId: view.viewInstanceId, templateId: view.templateId, label: view.label, rendererId: view.rendererId, modes: clone(view.modes), order: view.order, enabled: view.enabled, config: clone(view.config), bindings: clone(view.bindings) }))
+    };
+  }
+  function runtimeSnapshot(project, componentSet, instances, options = {}) {
+    const title = String(instances.find(instance => runtimeInstance(instance) && instance.templateId === "ssobig.basic")?.data?.title || "");
+    const archived = Array.isArray(options.archivedInstances) ? options.archivedInstances : [];
+    return { schemaVersion: "ssobig-writer-component-runtime-snapshot-v3", project: { id: String(project?.id || ""), slug: String(project?.slug || ""), title, authorName: String(project?.author_name || project?.authorName || ""), storagePrefix: String(options.storagePrefix || "") }, componentSet: { versionNumber: Number(componentSet?.version_number || 0), revision: Number(componentSet?.revision || 0), checksum: String(componentSet?.component_checksum || "") }, dataComponents: instances.map(instance => ({ ...instance, capabilities: clone(instance.capabilities), viewSelection: clone(instance.viewSelection), config: clone(instance.config), data: clone(instance.data) })), archivedDataComponents: archived.map(instance => ({ ...instance, capabilities: clone(instance.capabilities), viewSelection: clone(instance.viewSelection), config: clone(instance.config), data: clone(instance.data) })), viewComponents: [] };
+  }
+  function compositionPayload(instances) { return instances.map(instancePayload); }
+  function instancePayload(instance) {
+    const component = componentSpec(instance?.templateId);
+    if (!component || REMOVED_VERSION_FIELDS.some(field => Object.hasOwn(instance, field)) || validateComponentData(component, instance.data)) {
+      throw contractError("SOMI_INVALID_COMPONENT_INSTANCE", "유효한 직접 Component data만 저장할 수 있습니다.");
+    }
+    return { instance_id: instance.instanceId, template_id: instance.templateId, tab_label: instance.tab, sort_order: instance.order, is_enabled: instance.enabled, is_archived: instance.archived, is_required: instance.required, is_removable: instance.removable, editor_view_id: instance.editorViewId, preview_view_id: instance.previewViewId, capabilities: clone(instance.capabilities), config: clone(instance.config), data: clone(instance.data) };
+  }
+  function assetInstance(instances) { const assets = instances.filter(instance => runtimeInstance(instance) && instance.templateId === "ssobig.assets"); if (assets.length !== 1) throw contractError("SOMI_INVALID_ASSET_COMPONENT", "활성 에셋 Component가 정확히 하나여야 합니다."); return assets[0]; }
+  function assetManifest(instances) { return clone(assetInstance(instances).data); }
+  function assetInstanceWithManifest(instance, value, revision = instance?.revision) { if (!instance || instance.templateId !== "ssobig.assets" || componentSpec("ssobig.assets").validate(value)) throw contractError("SOMI_INVALID_ASSET_COMPONENT", "유효한 에셋 Component 데이터가 필요합니다."); return { ...instance, data: clone(value), revision: Number(revision) }; }
+
+  return Object.freeze({ MANIFEST_SCHEMA_VERSION, SUPPORTED_COMPONENTS: COMPONENT_SPECS, REQUIRED_COMPONENTS, componentSpec, normalizeInstance, runtimeInstance, validateActiveComposition, validateRuntimeComposition, archivedInstances, manifest, runtimeSnapshot, compositionPayload, instancePayload, assetInstance, assetManifest, assetInstanceWithManifest });
+});