@ssobig/writer-cli 0.2.0

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

@@ -0,0 +1,595 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === "object" && module.exports) module.exports = api;
+  if (root) root.WriterWorkbenchComponentFieldContracts = api;
+})(typeof globalThis !== "undefined" ? globalThis : this, function () {
+  "use strict";
+
+  const IDENTITY = Object.freeze({
+    UUID: Object.freeze({ field: "id", format: "uuid", visibility: "hidden" }),
+    STABLE_KEY: Object.freeze({ source: "object-key", format: "stable-key", visibility: "hidden" })
+  });
+
+  function field(type, options = {}) {
+    return { type, ...options };
+  }
+  function shape(required = {}, optional = {}, options = {}) {
+    return { required, optional, additionalProperties: false, ...options };
+  }
+  function component(input) {
+    return {
+      templateId: input.templateId,
+      identityPolicy: input.identityPolicy || null,
+      root: input.root,
+      items: input.items || {},
+      maps: input.maps || {}
+    };
+  }
+  function deepFreeze(value) {
+    if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+    Object.values(value).forEach(deepFreeze);
+    return Object.freeze(value);
+  }
+
+  const SECTION_ITEM = shape({
+    id: field("uuid", { role: "technical-identity", visibility: "hidden" }),
+    title: field("non-empty-string", { role: "display-title" }),
+    body: field("string", { role: "content" })
+  });
+  const CONTRACTS = deepFreeze([
+    component({
+      templateId: "ssobig.basic",
+      root: shape({ title: field("non-empty-string", { role: "display-title" }) }, {
+        intro: field("string"), detail: field("string"), minPlayers: field("non-negative-integer"),
+        maxPlayers: field("non-negative-integer"), brandColor: field("hex-color"),
+        backgroundColor: field("hex-color"), theme: field("enum", { values: ["light", "dark"] }), font: field("string")
+      })
+    }),
+    component({
+      templateId: "ssobig.progress",
+      identityPolicy: IDENTITY.UUID,
+      root: shape({ steps: field("array", { item: "progressStep" }) }),
+      items: {
+        progressStep: shape({
+          id: field("uuid", { role: "technical-identity", visibility: "hidden" }),
+          name: field("non-empty-string", { role: "display-name" })
+        }, {
+          time: field("string"), description: field("string"), actions: field("string")
+        })
+      }
+    }),
+    ...["ssobig.common", "ssobig.choice"].map(templateId => component({
+      templateId,
+      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")
+      }),
+      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" })
+      }
+    })),
+    component({
+      templateId: "ssobig.character",
+      identityPolicy: IDENTITY.STABLE_KEY,
+      root: shape({
+        characters: field("object-map", { values: "character", keyFormat: "stable-key" }), names: field("non-empty-string-map", { keyFormat: "stable-key" }),
+        order: field("unique-string-array"), customCharacters: field("array", { item: "customCharacterRef" }),
+        deletedColumns: field("unique-string-array", { keyFormat: "stable-key" })
+      }, {
+        enabledOptionalFields: field("unique-string-array")
+      }),
+      items: {
+        character: shape({
+          isPlayable: field("boolean", { role: "player-character-discriminator" }),
+          customSections: field("array", { item: "section" }),
+          containers: field("array", { item: "characterContainer" })
+        }, {
+          color: field("hex-color"), tag: field("string"), authorNote: field("string")
+        }),
+        section: SECTION_ITEM,
+        characterContainer: shape({
+          id: field("uuid", { role: "technical-identity", visibility: "hidden" }),
+          role: field("enum", { values: ["primary", "content"] }),
+          title: field("non-empty-string", { role: "display-title" }),
+          sectionIds: field("unique-uuid-array")
+        }),
+        customCharacterRef: shape({ id: field("stable-key", { references: "characters key" }) }),
+      }
+    }),
+    component({
+      templateId: "ssobig.clues",
+      identityPolicy: IDENTITY.UUID,
+      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" }),
+          name: field("non-empty-string", { role: "display-name" }),
+          title: field("string", { role: "content-title" }),
+          description: field("string", { role: "content" })
+        }, {
+          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"),
+          kind: field("string"), point: field("string"), spot: field("string"), character: field("string"),
+          related: field("string"), sourceId: field("string"), useTargetType: field("string"), onlyPositiveAllowed: field("boolean")
+        })
+      }
+    }),
+    component({
+      templateId: "ssobig.clue-combinations",
+      identityPolicy: IDENTITY.UUID,
+      root: shape({ combinations: field("array", { item: "combination" }) }),
+      items: {
+        combination: shape({
+          id: field("uuid", { role: "technical-identity", visibility: "hidden" }),
+          name: field("non-empty-string", { role: "display-name" }),
+          conditions: field("array", { item: "combinationCondition" }),
+          results: field("array", { item: "combinationResult" }),
+          hint: field("string")
+        }),
+        combinationCondition: shape({
+          kind: field("enum", { values: ["clue", "output", "literal"] })
+        }, {
+          clueId: field("uuid", { references: "ssobig.clues[].id" }),
+          outputId: field("uuid", { references: "combination result id" }),
+          value: field("non-empty-string")
+        }),
+        combinationResult: shape({
+          id: field("uuid", { role: "technical-identity", visibility: "hidden" }),
+          kind: field("enum", { values: ["clue", "literal"] })
+        }, {
+          clueId: field("uuid", { references: "ssobig.clues[].id" }),
+          value: field("non-empty-string")
+        })
+      }
+    }),
+    component({
+      templateId: "ssobig.ai-response",
+      identityPolicy: IDENTITY.UUID,
+      root: shape({ responses: field("array", { item: "response" }) }),
+      items: {
+        response: shape({
+          id: field("uuid", { visibility: "hidden" }), trigger: field("non-empty-string", { role: "display-name" }),
+          answer: field("string")
+        })
+      }
+    }),
+    component({
+      templateId: "ssobig.timeline",
+      identityPolicy: IDENTITY.UUID,
+      root: shape({ events: field("array", { item: "event" }) }),
+      items: {
+        event: shape({
+          id: field("uuid", { visibility: "hidden" }), time: field("non-empty-string", { role: "display-name" }),
+          truth: field("string"), memories: field("object-map", { values: "memory", keyFormat: "stable-key", keyReferences: "ssobig.character key" })
+        }, {
+          location: field("string"),
+          unassignedMemories: field("object-map", {
+            values: "memory", keyFormat: "stable-key", keyRole: "unresolved-character-key"
+          })
+        }),
+        memory: shape({ included: field("boolean"), text: field("string") })
+      }
+    }),
+    component({
+      templateId: "ssobig.ending",
+      identityPolicy: IDENTITY.UUID,
+      root: shape({ conditions: field("array", { item: "condition" }), outcomes: field("array", { item: "outcome" }) }),
+      items: {
+        condition: shape({
+          id: field("uuid", { visibility: "hidden" }), condition: field("string")
+        }, { code: field("string") }),
+        outcome: shape({
+          id: field("uuid", { visibility: "hidden", references: "condition.id" }),
+          title: field("non-empty-string", { role: "display-title" }), body: field("string")
+        }, { customSections: field("array", { item: "section" }) }),
+        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,
+      root: shape({ notes: field("array", { item: "note" }) }),
+      items: {
+        note: shape({
+          id: field("uuid", { visibility: "hidden" }),
+          title: field("string", { role: "display-title" }), body: field("string")
+        })
+      }
+    }),
+    component({
+      templateId: "ssobig.investigation-board",
+      identityPolicy: IDENTITY.STABLE_KEY,
+      root: shape({
+        viewport: field("object", { item: "boardViewport" }),
+        nodes: field("array", { item: "boardNode" }),
+        edges: field("array", { item: "boardEdge" })
+      }),
+      items: {
+        boardViewport: shape({
+          width: field("integer", { minimum: 800, maximum: 10000 }),
+          height: field("integer", { minimum: 600, maximum: 10000 })
+        }),
+        boardNode: shape({
+          id: field("stable-key", { visibility: "hidden" }),
+          type: field("enum", { values: ["reference", "sticky"] }),
+          x: field("integer", { minimum: 0, maximum: 10000 }),
+          y: field("integer", { minimum: 0, maximum: 10000 }),
+          width: field("integer", { minimum: 140, maximum: 10000 }),
+          height: field("integer", { minimum: 100, maximum: 10000 }),
+          color: field("hex-color")
+        }, {
+          title: field("string"), text: field("string"),
+          referenceType: field("enum", { values: ["character", "clue"] }),
+          referenceId: field("non-empty-string")
+        }),
+        boardEdge: shape({
+          id: field("stable-key", { visibility: "hidden" }),
+          fromNodeId: field("stable-key"), toNodeId: field("stable-key"),
+          direction: field("enum", { values: ["none", "forward", "both"] }),
+          label: field("string"), color: field("hex-color")
+        })
+      }
+    }),
+    component({
+      templateId: "ssobig.assets",
+      root: shape({ assets: field("object-map", { values: ["asset", "tombstone"] }) }),
+      items: {
+        asset: shape({
+          path: field("safe-storage-relative-path"), name: field("non-empty-string"), type: field("supported-mime"),
+          contentHash: field("non-empty-string"), operationId: field("non-empty-string"), updatedAt: field("non-negative-integer")
+        }, { size: field("integer", { minimum: 0, maximum: 15728640 }) }),
+        tombstone: shape({ deleted: field("literal", { value: true }), operationId: field("non-empty-string"), updatedAt: field("non-negative-integer") })
+      }
+    }),
+    component({
+      templateId: "ssobig.documents",
+      identityPolicy: IDENTITY.UUID,
+      root: shape({ blocks: field("array", { item: "document" }) }),
+      items: {
+        document: shape({
+          id: field("uuid", { visibility: "hidden" }), title: field("non-empty-string", { role: "display-title" }), body: field("string")
+        })
+      }
+    })
+  ]);
+
+  const BY_ID = new Map(CONTRACTS.map(contract => [contract.templateId, contract]));
+  const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  const STABLE_KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+  const HEX_COLOR_PATTERN = /^#[0-9a-f]{6}$/i;
+  const SUPPORTED_MIME_TYPES = ["image/jpeg", "image/png", "image/webp", "image/gif", "application/json"];
+
+  function isObject(value) { return Boolean(value && typeof value === "object" && !Array.isArray(value)); }
+  function clone(value) {
+    if (Array.isArray(value)) return value.map(clone);
+    if (isObject(value)) return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, clone(child)]));
+    return value;
+  }
+  function schemaForShape(shapeDefinition, contract) {
+    const properties = Object.fromEntries([...Object.entries(shapeDefinition.required), ...Object.entries(shapeDefinition.optional)]
+      .map(([name, definition]) => [name, schemaForField(definition, contract)]));
+    return {
+      type: "object",
+      additionalProperties: shapeDefinition.additionalProperties === true,
+      required: Object.keys(shapeDefinition.required),
+      properties
+    };
+  }
+  function schemaForNamedItem(name, contract) {
+    const item = contract.items[name];
+    if (!item) throw new Error(`${contract.templateId}에 등록되지 않은 item 계약입니다: ${name}`);
+    return schemaForShape(item, contract);
+  }
+  function schemaForAlternatives(values, contract) {
+    const definitions = Array.isArray(values) ? values : [values];
+    const schemas = definitions.map(value => contract.items[value]
+      ? schemaForNamedItem(value, contract)
+      : schemaForField(field(value), contract));
+    return schemas.length === 1 ? schemas[0] : { oneOf: schemas };
+  }
+  function schemaForField(definition, contract) {
+    switch (definition.type) {
+      case "string": return { type: "string" };
+      case "non-empty-string": return { type: "string", minLength: 1, pattern: "\\S" };
+      case "stable-key": return { type: "string", pattern: STABLE_KEY_PATTERN.source };
+      case "uuid": return { type: "string", format: "uuid" };
+      case "hex-color": return { type: "string", pattern: HEX_COLOR_PATTERN.source };
+      case "hex-color-or-empty": return { type: "string", pattern: `^(?:|#[0-9a-fA-F]{6})$` };
+      case "safe-storage-relative-path": return { type: "string", minLength: 1 };
+      case "supported-mime": return { type: "string", enum: SUPPORTED_MIME_TYPES.slice() };
+      case "number": return { type: "number" };
+      case "positive-number": return { type: "number", exclusiveMinimum: 0 };
+      case "integer": {
+        const schema = { type: "integer" };
+        if (definition.minimum !== undefined) schema.minimum = definition.minimum;
+        if (definition.maximum !== undefined) schema.maximum = definition.maximum;
+        return schema;
+      }
+      case "non-negative-integer": return { type: "integer", minimum: 0 };
+      case "boolean": return { type: "boolean" };
+      case "null": return { type: "null" };
+      case "literal": return { const: definition.value };
+      case "enum": return { enum: definition.values.slice() };
+      case "array": return { type: "array", items: schemaForNamedItem(definition.item, contract) };
+      case "string-array": return { type: "array", items: { type: "string", ...(definition.keyFormat === "stable-key" ? { pattern: STABLE_KEY_PATTERN.source } : {}) } };
+      case "unique-string-array": return { type: "array", uniqueItems: true, items: { type: "string", ...(definition.keyFormat === "stable-key" ? { pattern: STABLE_KEY_PATTERN.source } : {}) } };
+      case "unique-uuid-array": return { type: "array", uniqueItems: true, items: { type: "string", format: "uuid" } };
+      case "unique-non-empty-string-array": return {
+        type: "array",
+        uniqueItems: true,
+        "x-ssobig-normalized-unique": true,
+        items: { type: "string", minLength: 1, pattern: definition.keyFormat === "stable-key" ? STABLE_KEY_PATTERN.source : "\\S" }
+      };
+      case "object": return definition.item ? schemaForNamedItem(definition.item, contract) : { type: "object" };
+      case "string-map":
+      case "non-empty-string-map":
+        return {
+          type: "object",
+          ...(definition.keyFormat === "stable-key" ? { propertyNames: { pattern: STABLE_KEY_PATTERN.source } } : {}),
+          additionalProperties: { type: "string", ...(definition.type === "non-empty-string-map" ? { minLength: 1, pattern: "\\S" } : {}) }
+        };
+      case "object-map": return {
+        type: "object",
+        ...(definition.keyFormat === "stable-key" ? { propertyNames: { pattern: STABLE_KEY_PATTERN.source } } : {}),
+        additionalProperties: schemaForAlternatives(definition.values, contract)
+      };
+      default: throw new Error(`${contract.templateId}에서 지원하지 않는 field type입니다: ${definition.type}`);
+    }
+  }
+  function jsonSchemaFor(templateId) {
+    const contract = getContract(templateId);
+    return contract ? clone(schemaForShape(contract.root, contract)) : null;
+  }
+
+  function validateShape(value, shapeDefinition, contract, path) {
+    if (!isObject(value)) return `${path} 값은 객체여야 합니다.`;
+    const allowed = new Set([...Object.keys(shapeDefinition.required), ...Object.keys(shapeDefinition.optional)]);
+    const unsupported = Object.keys(value).find(key => !allowed.has(key));
+    if (unsupported) return `${path}.${unsupported} 필드는 지원되지 않습니다.`;
+    for (const [name, definition] of Object.entries(shapeDefinition.required)) {
+      if (!Object.hasOwn(value, name)) return `${path}.${name} 필드는 필수입니다.`;
+      const invalid = validateField(value[name], definition, contract, `${path}.${name}`);
+      if (invalid) return invalid;
+    }
+    for (const [name, definition] of Object.entries(shapeDefinition.optional)) {
+      if (!Object.hasOwn(value, name)) continue;
+      const invalid = validateField(value[name], definition, contract, `${path}.${name}`);
+      if (invalid) return invalid;
+    }
+    return null;
+  }
+  function validateNamedItem(value, name, contract, path) {
+    const definition = contract.items[name];
+    return definition ? validateShape(value, definition, contract, path) : `${path}의 item 계약(${name})이 등록되지 않았습니다.`;
+  }
+  function validateAlternatives(value, values, contract, path) {
+    const definitions = Array.isArray(values) ? values : [values];
+    for (const candidate of definitions) {
+      const invalid = contract.items[candidate]
+        ? validateNamedItem(value, candidate, contract, path)
+        : validateField(value, field(candidate), contract, path);
+      if (!invalid) return null;
+    }
+    return `${path} 값이 허용된 형식과 일치하지 않습니다.`;
+  }
+  function validateField(value, definition, contract, path) {
+    switch (definition.type) {
+      case "string": return typeof value === "string" ? null : `${path} 값은 문자열이어야 합니다.`;
+      case "non-empty-string": return typeof value === "string" && value.trim() ? null : `${path} 값은 비어 있지 않은 문자열이어야 합니다.`;
+      case "stable-key": return typeof value === "string" && STABLE_KEY_PATTERN.test(value) ? null : `${path} 값은 안정 식별자 형식이어야 합니다.`;
+      case "uuid": return typeof value === "string" && UUID_PATTERN.test(value) ? null : `${path} 값은 UUID여야 합니다.`;
+      case "hex-color": return typeof value === "string" && HEX_COLOR_PATTERN.test(value) ? null : `${path} 값은 #RRGGBB 색상이어야 합니다.`;
+      case "hex-color-or-empty": return typeof value === "string" && (!value || HEX_COLOR_PATTERN.test(value)) ? null : `${path} 값은 빈 문자열 또는 #RRGGBB 색상이어야 합니다.`;
+      case "safe-storage-relative-path": return typeof value === "string" && value && !/^(?:[a-z]+:|\/|\\)/i.test(value) && !value.split(/[\\/]/).some(segment => !segment || segment === "." || segment === "..") ? null : `${path} 값은 안전한 상대 경로여야 합니다.`;
+      case "supported-mime": return typeof value === "string" && SUPPORTED_MIME_TYPES.includes(value.toLowerCase()) ? null : `${path} 값은 지원하는 MIME 형식이어야 합니다.`;
+      case "number": return typeof value === "number" && Number.isFinite(value) ? null : `${path} 값은 유한한 숫자여야 합니다.`;
+      case "positive-number": return typeof value === "number" && Number.isFinite(value) && value > 0 ? null : `${path} 값은 0보다 큰 숫자여야 합니다.`;
+      case "integer": return Number.isSafeInteger(value) && (definition.minimum === undefined || value >= definition.minimum) && (definition.maximum === undefined || value <= definition.maximum) ? null : `${path} 값은 허용 범위의 정수여야 합니다.`;
+      case "non-negative-integer": return Number.isSafeInteger(value) && value >= 0 ? null : `${path} 값은 0 이상의 정수여야 합니다.`;
+      case "boolean": return typeof value === "boolean" ? null : `${path} 값은 boolean이어야 합니다.`;
+      case "null": return value === null ? null : `${path} 값은 null이어야 합니다.`;
+      case "literal": return value === definition.value ? null : `${path} 값은 ${String(definition.value)}여야 합니다.`;
+      case "enum": return definition.values.includes(value) ? null : `${path} 값은 ${definition.values.join(", ")} 중 하나여야 합니다.`;
+      case "array": {
+        if (!Array.isArray(value)) return `${path} 값은 배열이어야 합니다.`;
+        const ids = new Set();
+        for (let index = 0; index < value.length; index += 1) {
+          const invalid = validateNamedItem(value[index], definition.item, contract, `${path}.${index}`);
+          if (invalid) return invalid;
+          const id = isObject(value[index]) ? value[index].id : undefined;
+          if (typeof id === "string") {
+            const normalized = id.toLowerCase();
+            if (ids.has(normalized)) return `${path}에 중복 id가 있습니다: ${id}`;
+            ids.add(normalized);
+          }
+        }
+        return null;
+      }
+      case "string-array": return Array.isArray(value) && value.every(item => typeof item === "string") ? null : `${path} 값은 문자열 배열이어야 합니다.`;
+      case "unique-string-array":
+      case "unique-uuid-array":
+      case "unique-non-empty-string-array": {
+        if (!Array.isArray(value) || value.some(item => typeof item !== "string"
+          || (definition.type === "unique-uuid-array" && !UUID_PATTERN.test(item))
+          || (definition.type === "unique-non-empty-string-array" && !item.trim())
+          || (definition.keyFormat === "stable-key" && !STABLE_KEY_PATTERN.test(item)))) {
+          return `${path} 값은 ${definition.type === "unique-uuid-array" ? "UUID " : definition.keyFormat === "stable-key" ? "안정 식별자 " : definition.type === "unique-non-empty-string-array" ? "비어 있지 않은 " : ""}문자열 배열이어야 합니다.`;
+        }
+        const comparable = definition.type === "unique-non-empty-string-array" ? value.map(item => item.trim()) : value;
+        return new Set(comparable).size === value.length ? null : `${path} 값에 중복이 있습니다.`;
+      }
+      case "object": return definition.item ? validateNamedItem(value, definition.item, contract, path) : isObject(value) ? null : `${path} 값은 객체여야 합니다.`;
+      case "string-map":
+      case "non-empty-string-map": {
+        if (!isObject(value)) return `${path} 값은 객체 map이어야 합니다.`;
+        const invalidKey = Object.keys(value).find(key => !key
+          || ["__proto__", "prototype", "constructor"].includes(key)
+          || (definition.keyFormat === "stable-key" && !STABLE_KEY_PATTERN.test(key)));
+        if (invalidKey) return `${path}.${invalidKey} key는 사용할 수 없습니다.`;
+        const invalidValue = Object.entries(value).find(([, item]) => typeof item !== "string" || (definition.type === "non-empty-string-map" && !item.trim()));
+        return invalidValue ? `${path}.${invalidValue[0]} 값은 ${definition.type === "non-empty-string-map" ? "비어 있지 않은 " : ""}문자열이어야 합니다.` : null;
+      }
+      case "object-map": {
+        if (!isObject(value)) return `${path} 값은 객체 map이어야 합니다.`;
+        for (const [key, item] of Object.entries(value)) {
+          if (!key || ["__proto__", "prototype", "constructor"].includes(key) || (definition.keyFormat === "stable-key" && !STABLE_KEY_PATTERN.test(key))) return `${path}.${key} key는 사용할 수 없습니다.`;
+          const invalid = validateAlternatives(item, definition.values, contract, `${path}.${key}`);
+          if (invalid) return invalid;
+        }
+        return null;
+      }
+      default: return `${path}에 지원되지 않는 field type(${definition.type})이 있습니다.`;
+    }
+  }
+  function idSet(items) { return new Set(items.map(item => String(item.id || "").toLowerCase())); }
+  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을 정확히 한 번 포함해야 합니다.";
+        return null;
+      }
+      case "ssobig.character": {
+        const allowedOptionalFields = new Set(["image", "color", "tag", "authorNote"]);
+        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의 표시 이름을 가져야 합니다.";
+        if (Object.keys(data.names).some(id => !characterIds.has(id))) return "$.names에 존재하지 않는 character가 있습니다.";
+        if (data.deletedColumns.some(id => characterIds.has(id))) return "$.deletedColumns는 현재 character가 아닌 삭제 이력 ID만 가져야 합니다.";
+        if (data.order.some(id => !characterIds.has(id) || data.deletedColumns.includes(id))) return "$.order에 활성 character를 가리키지 않는 값이 있습니다.";
+        if (data.customCharacters.some(item => !characterIds.has(item.id))) return "$.customCharacters에 존재하지 않는 character가 있습니다.";
+        const activeIds = [...characterIds];
+        if (data.order.length !== activeIds.length || activeIds.some(id => !data.order.includes(id))) return "$.order는 모든 활성 character를 정확히 한 번 포함해야 합니다.";
+        for (const [characterId, character] of Object.entries(data.characters)) {
+          if (!character.containers.length || character.containers[0].role !== "primary") return `$.characters.${characterId}.containers의 첫 항목은 primary Container여야 합니다.`;
+          if (character.containers.slice(1).some(container => container.role !== "content")) return `$.characters.${characterId}.containers에는 primary Container가 정확히 하나만 있어야 합니다.`;
+          const sectionIds = idSet(character.customSections);
+          const placedIds = character.containers.flatMap(container => container.sectionIds.map(id => id.toLowerCase()));
+          if (placedIds.some(id => !sectionIds.has(id))) return `$.characters.${characterId}.containers가 존재하지 않는 custom section을 참조합니다.`;
+          if (new Set(placedIds).size !== placedIds.length) return `$.characters.${characterId}.customSections는 하나의 Container에만 배치해야 합니다.`;
+          if (placedIds.length !== sectionIds.size || [...sectionIds].some(id => !placedIds.includes(id))) return `$.characters.${characterId}.containers는 모든 custom section을 정확히 한 번 배치해야 합니다.`;
+        }
+        return null;
+      }
+      case "ssobig.clues": {
+        const allowed = new Set(["confirmed", "image", "location", "tags", "color", "secret"]);
+        return data.enabledOptionalFields.some(name => !allowed.has(name))
+          ? "$.enabledOptionalFields에 지원하지 않는 단서 선택 속성이 있습니다." : null;
+      }
+      case "ssobig.clue-combinations": {
+        const fieldsByConditionKind = {
+          clue: ["clueId"],
+          output: ["outputId"],
+          literal: ["value"]
+        };
+        const fieldsByResultKind = {
+          clue: ["clueId"],
+          literal: ["value"]
+        };
+        const discriminatorError = (item, expected, fields, path) => {
+          if (!expected.every(fieldName => Object.hasOwn(item, fieldName))) return `${path}에 ${item.kind} 종류의 필수 값이 없습니다.`;
+          const unexpected = fields.find(fieldName => !expected.includes(fieldName) && Object.hasOwn(item, fieldName));
+          return unexpected ? `${path}.${unexpected} 필드는 ${item.kind} 종류에서 사용할 수 없습니다.` : null;
+        };
+        for (let combinationIndex = 0; combinationIndex < data.combinations.length; combinationIndex += 1) {
+          const combination = data.combinations[combinationIndex];
+          for (let conditionIndex = 0; conditionIndex < combination.conditions.length; conditionIndex += 1) {
+            const condition = combination.conditions[conditionIndex];
+            const invalid = discriminatorError(
+              condition,
+              fieldsByConditionKind[condition.kind],
+              ["clueId", "outputId", "value"],
+              `$.combinations.${combinationIndex}.conditions.${conditionIndex}`
+            );
+            if (invalid) return invalid;
+          }
+          for (let resultIndex = 0; resultIndex < combination.results.length; resultIndex += 1) {
+            const result = combination.results[resultIndex];
+            const invalid = discriminatorError(
+              result,
+              fieldsByResultKind[result.kind],
+              ["clueId", "value"],
+              `$.combinations.${combinationIndex}.results.${resultIndex}`
+            );
+            if (invalid) return invalid;
+          }
+        }
+        return null;
+      }
+      case "ssobig.investigation-board": {
+        const nodeIds = new Set();
+        for (const node of data.nodes) {
+          if (nodeIds.has(node.id)) return `$.nodes에 중복된 보드 node id가 있습니다: ${node.id}`;
+          nodeIds.add(node.id);
+          if (node.type === "sticky") {
+            if (typeof node.title !== "string" || typeof node.text !== "string" || Object.hasOwn(node, "referenceType") || Object.hasOwn(node, "referenceId")) return "$.nodes sticky 필드가 올바르지 않습니다.";
+          } else if (!["character", "clue"].includes(node.referenceType) || typeof node.referenceId !== "string" || !node.referenceId.trim() || Object.hasOwn(node, "title") || Object.hasOwn(node, "text")) return "$.nodes reference 필드가 올바르지 않습니다.";
+        }
+        const edgeIds = new Set();
+        for (const edge of data.edges) {
+          if (edgeIds.has(edge.id)) return `$.edges에 중복된 보드 edge id가 있습니다: ${edge.id}`;
+          edgeIds.add(edge.id);
+          if (!nodeIds.has(edge.fromNodeId) || !nodeIds.has(edge.toNodeId) || edge.fromNodeId === edge.toNodeId) return "$.edges 연결 node가 올바르지 않습니다.";
+        }
+        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;
+    }
+  }
+  function validateTargetData(templateId, data) {
+    const contract = getContract(templateId);
+    if (!contract) return `지원하지 않는 Component 계약입니다: ${templateId}`;
+    const invalid = validateShape(data, contract.root, contract, "$");
+    return invalid || validateRelations(contract, data);
+  }
+
+  function getContract(templateId) { return BY_ID.get(String(templateId || "")) || null; }
+  function listContracts() { return CONTRACTS.slice(); }
+
+  return Object.freeze({ IDENTITY, CONTRACTS, getContract, listContracts, jsonSchemaFor, validateTargetData });
+});

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

@@ -0,0 +1,64 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === "object" && module.exports) module.exports = api;
+  if (root) root.WriterWorkbenchComponentIdPolicy = api;
+})(typeof globalThis !== "undefined" ? globalThis : this, function () {
+  "use strict";
+
+  function getAt(root, path) {
+    return path.reduce((value, key) => value?.[key], root);
+  }
+
+  function setAt(root, path, value) {
+    if (!path.length) throw new Error("Component field path가 비어 있습니다.");
+    let cursor = root;
+    for (const key of path.slice(0, -1)) {
+      if (!cursor || typeof cursor !== "object") throw new Error("Component field path를 찾을 수 없습니다.");
+      cursor = cursor[key];
+    }
+    cursor[path.at(-1)] = value;
+  }
+
+  function normalizedComponentId(value, now = Date.now) {
+    const normalized = String(value || "").trim().toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .replace(/-+/g, "-");
+    return /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(normalized) ? normalized : `document-${now().toString(36)}`;
+  }
+
+  function normalizedAssetId(value, fileName = "", now = Date.now) {
+    const requested = String(value || "").trim();
+    const fileStem = String(fileName || "").replace(/\.[^.]+$/, "");
+    let normalized = (requested || fileStem).normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    if (!normalized || !/^[a-z]/.test(normalized)) normalized = `asset-${normalized || now().toString(36)}`;
+    normalized = normalized.slice(0, 120).replace(/-+$/g, "");
+    return /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(normalized) ? normalized : "";
+  }
+
+  function uniqueId(prefix, occupied, now = Date.now) {
+    let id = `${prefix}-${now().toString(36)}`;
+    let suffix = 2;
+    while (occupied.has(id)) id = `${prefix}-${now().toString(36)}-${suffix++}`;
+    return id;
+  }
+
+  function technicalId(instance, prefix, occupied, options = {}) {
+    const uuidContract = ["ssobig.character", "ssobig.common", "ssobig.choice"].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 생성 기능을 사용할 수 없습니다.");
+    let id = randomUUID();
+    while (occupied.has(id)) id = randomUUID();
+    return id;
+  }
+
+  return Object.freeze({
+    getAt,
+    setAt,
+    normalizedComponentId,
+    normalizedAssetId,
+    uniqueId,
+    technicalId
+  });
+});