@character-foundry/character-foundry 0.1.3 → 0.1.5

package/dist/schemas.cjs

@@ -0,0 +1,799 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  AssetDescriptorSchema: () => AssetDescriptorSchema,
+  AssetTypeSchema: () => AssetTypeSchema,
+  CCv2CharacterBookSchema: () => CCv2CharacterBookSchema,
+  CCv2DataSchema: () => CCv2DataSchema,
+  CCv2LorebookEntrySchema: () => CCv2LorebookEntrySchema,
+  CCv2WrappedSchema: () => CCv2WrappedSchema,
+  CCv3CharacterBookSchema: () => CCv3CharacterBookSchema,
+  CCv3DataInnerSchema: () => CCv3DataInnerSchema,
+  CCv3DataSchema: () => CCv3DataSchema,
+  CCv3LorebookEntrySchema: () => CCv3LorebookEntrySchema,
+  CardNormalizer: () => CardNormalizer,
+  ExtractedAssetSchema: () => ExtractedAssetSchema,
+  ISO8601Schema: () => ISO8601Schema,
+  OriginalShapeSchema: () => OriginalShapeSchema,
+  SourceFormatSchema: () => SourceFormatSchema,
+  SpecSchema: () => SpecSchema,
+  UUIDSchema: () => UUIDSchema,
+  createEmptyFeatures: () => createEmptyFeatures,
+  createEmptyNormalizedCard: () => createEmptyNormalizedCard,
+  detectSpec: () => detectSpec,
+  detectSpecDetailed: () => detectSpecDetailed,
+  getFirstErrorField: () => getFirstErrorField,
+  getV2Data: () => getV2Data,
+  getV3Data: () => getV3Data,
+  hasDepthPrompt: () => hasDepthPrompt,
+  hasLorebook: () => hasLorebook,
+  hasRisuExtensions: () => hasRisuExtensions,
+  hasRisuScripts: () => hasRisuScripts,
+  isV2CardData: () => isV2CardData,
+  isV3Card: () => isV3Card,
+  isWrappedV2: () => isWrappedV2,
+  looksLikeCard: () => looksLikeCard,
+  looksLikeV3Card: () => looksLikeV3Card,
+  looksLikeWrappedV2: () => looksLikeWrappedV2,
+  parseV2Data: () => parseV2Data,
+  parseV3Card: () => parseV3Card,
+  parseV3DataInner: () => parseV3DataInner,
+  parseWrappedV2: () => parseWrappedV2,
+  safeParse: () => safeParse,
+  zodErrorToMessage: () => zodErrorToMessage
+});
+module.exports = __toCommonJS(schemas_exports);
+
+// ../schemas/dist/index.js
+var import_zod = require("zod");
+var import_zod2 = require("zod");
+var import_zod3 = require("zod");
+var import_zod4 = require("zod");
+var ISO8601Schema = import_zod.z.string().datetime();
+var UUIDSchema = import_zod.z.string().uuid();
+var SpecSchema = import_zod.z.enum(["v2", "v3"]);
+var SourceFormatSchema = import_zod.z.enum([
+  "png_v2",
+  // PNG with 'chara' chunk (v2)
+  "png_v3",
+  // PNG with 'ccv3' chunk (v3)
+  "json_v2",
+  // Raw JSON v2
+  "json_v3",
+  // Raw JSON v3
+  "charx",
+  // ZIP with card.json (v3 spec)
+  "charx_risu",
+  // ZIP with card.json + module.risum
+  "charx_jpeg",
+  // JPEG with appended ZIP (read-only)
+  "voxta"
+  // VoxPkg format
+]);
+var OriginalShapeSchema = import_zod.z.enum(["wrapped", "unwrapped", "legacy"]);
+var AssetTypeSchema = import_zod.z.enum([
+  "icon",
+  "background",
+  "emotion",
+  "user_icon",
+  "sound",
+  "video",
+  "custom",
+  "x-risu-asset"
+]);
+var AssetDescriptorSchema = import_zod.z.object({
+  type: AssetTypeSchema,
+  uri: import_zod.z.string(),
+  name: import_zod.z.string(),
+  ext: import_zod.z.string()
+});
+var ExtractedAssetSchema = import_zod.z.object({
+  descriptor: AssetDescriptorSchema,
+  data: import_zod.z.instanceof(Uint8Array),
+  mimeType: import_zod.z.string()
+});
+var CCv2LorebookEntrySchema = import_zod2.z.object({
+  keys: import_zod2.z.array(import_zod2.z.string()),
+  content: import_zod2.z.string(),
+  enabled: import_zod2.z.boolean(),
+  insertion_order: import_zod2.z.number().int(),
+  // Optional fields
+  extensions: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  case_sensitive: import_zod2.z.boolean().optional(),
+  name: import_zod2.z.string().optional(),
+  priority: import_zod2.z.number().int().optional(),
+  id: import_zod2.z.number().int().optional(),
+  comment: import_zod2.z.string().optional(),
+  selective: import_zod2.z.boolean().optional(),
+  secondary_keys: import_zod2.z.array(import_zod2.z.string()).optional(),
+  constant: import_zod2.z.boolean().optional(),
+  position: import_zod2.z.enum(["before_char", "after_char"]).optional()
+});
+var CCv2CharacterBookSchema = import_zod2.z.object({
+  name: import_zod2.z.string().optional(),
+  description: import_zod2.z.string().optional(),
+  scan_depth: import_zod2.z.number().int().nonnegative().optional(),
+  token_budget: import_zod2.z.number().int().nonnegative().optional(),
+  recursive_scanning: import_zod2.z.boolean().optional(),
+  extensions: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  entries: import_zod2.z.array(CCv2LorebookEntrySchema)
+});
+var CCv2DataSchema = import_zod2.z.object({
+  // Core fields - use .default('') to handle missing fields in malformed cards
+  name: import_zod2.z.string().default(""),
+  description: import_zod2.z.string().default(""),
+  personality: import_zod2.z.string().nullable().default(""),
+  // Can be null in wild (141 cards)
+  scenario: import_zod2.z.string().default(""),
+  first_mes: import_zod2.z.string().default(""),
+  mes_example: import_zod2.z.string().nullable().default(""),
+  // Can be null in wild (186 cards)
+  // Optional fields
+  creator_notes: import_zod2.z.string().optional(),
+  system_prompt: import_zod2.z.string().optional(),
+  post_history_instructions: import_zod2.z.string().optional(),
+  alternate_greetings: import_zod2.z.array(import_zod2.z.string()).optional(),
+  character_book: CCv2CharacterBookSchema.optional().nullable(),
+  tags: import_zod2.z.array(import_zod2.z.string()).optional(),
+  creator: import_zod2.z.string().optional(),
+  character_version: import_zod2.z.string().optional(),
+  extensions: import_zod2.z.record(import_zod2.z.unknown()).optional()
+});
+var CCv2WrappedSchema = import_zod2.z.object({
+  spec: import_zod2.z.literal("chara_card_v2"),
+  spec_version: import_zod2.z.literal("2.0"),
+  data: CCv2DataSchema
+});
+function isWrappedV2(data) {
+  return CCv2WrappedSchema.safeParse(data).success;
+}
+function isV2CardData(data) {
+  return CCv2WrappedSchema.safeParse(data).success || CCv2DataSchema.safeParse(data).success;
+}
+function parseWrappedV2(data) {
+  return CCv2WrappedSchema.parse(data);
+}
+function parseV2Data(data) {
+  return CCv2DataSchema.parse(data);
+}
+function looksLikeWrappedV2(data) {
+  if (!data || typeof data !== "object") return false;
+  const obj = data;
+  return obj.spec === "chara_card_v2" && obj.data !== null && typeof obj.data === "object";
+}
+function getV2Data(card) {
+  if (looksLikeWrappedV2(card)) {
+    return card.data;
+  }
+  return card;
+}
+var CCv3LorebookEntrySchema = import_zod3.z.object({
+  keys: import_zod3.z.array(import_zod3.z.string()),
+  content: import_zod3.z.string(),
+  enabled: import_zod3.z.boolean(),
+  insertion_order: import_zod3.z.number().int(),
+  // Optional fields
+  case_sensitive: import_zod3.z.boolean().optional(),
+  name: import_zod3.z.string().optional(),
+  priority: import_zod3.z.number().int().optional(),
+  id: import_zod3.z.number().int().optional(),
+  comment: import_zod3.z.string().optional(),
+  selective: import_zod3.z.boolean().optional(),
+  secondary_keys: import_zod3.z.array(import_zod3.z.string()).optional(),
+  constant: import_zod3.z.boolean().optional(),
+  position: import_zod3.z.enum(["before_char", "after_char"]).optional(),
+  extensions: import_zod3.z.record(import_zod3.z.unknown()).optional(),
+  // v3 specific
+  automation_id: import_zod3.z.string().optional(),
+  role: import_zod3.z.enum(["system", "user", "assistant"]).optional(),
+  group: import_zod3.z.string().optional(),
+  scan_frequency: import_zod3.z.number().int().nonnegative().optional(),
+  probability: import_zod3.z.number().min(0).max(1).optional(),
+  use_regex: import_zod3.z.boolean().optional(),
+  depth: import_zod3.z.number().int().nonnegative().optional(),
+  selective_logic: import_zod3.z.enum(["AND", "NOT"]).optional()
+});
+var CCv3CharacterBookSchema = import_zod3.z.object({
+  name: import_zod3.z.string().optional(),
+  description: import_zod3.z.string().optional(),
+  scan_depth: import_zod3.z.number().int().nonnegative().optional(),
+  token_budget: import_zod3.z.number().int().nonnegative().optional(),
+  recursive_scanning: import_zod3.z.boolean().optional(),
+  extensions: import_zod3.z.record(import_zod3.z.unknown()).optional(),
+  entries: import_zod3.z.array(CCv3LorebookEntrySchema)
+});
+var CCv3DataInnerSchema = import_zod3.z.object({
+  // Core fields - use .default('') to handle missing fields in malformed cards
+  name: import_zod3.z.string().default(""),
+  description: import_zod3.z.string().default(""),
+  personality: import_zod3.z.string().nullable().default(""),
+  // Can be null in wild (141 cards)
+  scenario: import_zod3.z.string().default(""),
+  first_mes: import_zod3.z.string().default(""),
+  mes_example: import_zod3.z.string().nullable().default(""),
+  // Can be null in wild (186 cards)
+  // "Required" per spec but often missing in wild - use defaults for leniency
+  creator: import_zod3.z.string().default(""),
+  character_version: import_zod3.z.string().default(""),
+  tags: import_zod3.z.array(import_zod3.z.string()).default([]),
+  group_only_greetings: import_zod3.z.array(import_zod3.z.string()).default([]),
+  // Optional fields
+  creator_notes: import_zod3.z.string().optional(),
+  system_prompt: import_zod3.z.string().optional(),
+  post_history_instructions: import_zod3.z.string().optional(),
+  alternate_greetings: import_zod3.z.array(import_zod3.z.string()).optional(),
+  character_book: CCv3CharacterBookSchema.optional().nullable(),
+  extensions: import_zod3.z.record(import_zod3.z.unknown()).optional(),
+  // v3 specific
+  assets: import_zod3.z.array(AssetDescriptorSchema).optional(),
+  nickname: import_zod3.z.string().optional(),
+  creator_notes_multilingual: import_zod3.z.record(import_zod3.z.string()).optional(),
+  source: import_zod3.z.array(import_zod3.z.string()).optional(),
+  creation_date: import_zod3.z.number().int().nonnegative().optional(),
+  // Unix timestamp in seconds
+  modification_date: import_zod3.z.number().int().nonnegative().optional()
+  // Unix timestamp in seconds
+});
+var CCv3DataSchema = import_zod3.z.object({
+  spec: import_zod3.z.literal("chara_card_v3"),
+  spec_version: import_zod3.z.literal("3.0"),
+  data: CCv3DataInnerSchema
+});
+function isV3Card(data) {
+  return CCv3DataSchema.safeParse(data).success;
+}
+function parseV3Card(data) {
+  return CCv3DataSchema.parse(data);
+}
+function parseV3DataInner(data) {
+  return CCv3DataInnerSchema.parse(data);
+}
+function getV3Data(card) {
+  return card.data;
+}
+function looksLikeV3Card(data) {
+  if (!data || typeof data !== "object") return false;
+  const obj = data;
+  return obj.spec === "chara_card_v3" && obj.data !== null && typeof obj.data === "object";
+}
+function hasRisuExtensions(extensions) {
+  if (!extensions) return false;
+  return "risuai" in extensions || "risu" in extensions;
+}
+function hasRisuScripts(extensions) {
+  if (!extensions) return false;
+  const risu = extensions.risuai;
+  if (!risu) return false;
+  return !!risu.triggerscript || !!risu.customScripts;
+}
+function hasDepthPrompt(extensions) {
+  if (!extensions) return false;
+  if ("depth_prompt" in extensions && extensions.depth_prompt) return true;
+  const risu = extensions.risuai;
+  return !!risu?.depth_prompt;
+}
+function createEmptyNormalizedCard() {
+  return {
+    name: "",
+    description: "",
+    personality: "",
+    scenario: "",
+    firstMes: "",
+    mesExample: "",
+    alternateGreetings: [],
+    groupOnlyGreetings: [],
+    tags: [],
+    extensions: {}
+  };
+}
+function createEmptyFeatures() {
+  return {
+    hasAlternateGreetings: false,
+    alternateGreetingsCount: 0,
+    hasLorebook: false,
+    lorebookEntriesCount: 0,
+    hasEmbeddedImages: false,
+    embeddedImagesCount: 0,
+    hasGallery: false,
+    hasRisuExtensions: false,
+    hasRisuScripts: false,
+    hasDepthPrompt: false,
+    hasVoxtaAppearance: false,
+    tokens: {
+      description: 0,
+      personality: 0,
+      scenario: 0,
+      firstMes: 0,
+      mesExample: 0,
+      systemPrompt: 0,
+      total: 0
+    }
+  };
+}
+var V3_ONLY_FIELDS = ["group_only_greetings", "creation_date", "modification_date", "assets"];
+function detectSpec(data) {
+  return detectSpecDetailed(data).spec;
+}
+function detectSpecDetailed(data) {
+  const result = {
+    spec: null,
+    confidence: "low",
+    indicators: [],
+    warnings: []
+  };
+  if (!data || typeof data !== "object") {
+    result.indicators.push("Input is not an object");
+    return result;
+  }
+  const obj = data;
+  const dataObj = obj.data && typeof obj.data === "object" ? obj.data : null;
+  if (obj.spec === "chara_card_v3") {
+    result.spec = "v3";
+    result.confidence = "high";
+    result.indicators.push('spec field is "chara_card_v3"');
+    if (obj.spec_version && obj.spec_version !== "3.0") {
+      result.warnings.push(`spec_version "${obj.spec_version}" inconsistent with v3 spec`);
+    }
+    return result;
+  }
+  if (obj.spec === "chara_card_v2") {
+    result.spec = "v2";
+    result.confidence = "high";
+    result.indicators.push('spec field is "chara_card_v2"');
+    if (dataObj) {
+      for (const field of V3_ONLY_FIELDS) {
+        if (field in dataObj) {
+          result.warnings.push(`V3-only field "${field}" found in V2 card`);
+        }
+      }
+    }
+    if (obj.spec_version && obj.spec_version !== "2.0") {
+      result.warnings.push(`spec_version "${obj.spec_version}" inconsistent with v2 spec`);
+    }
+    return result;
+  }
+  if (typeof obj.spec_version === "string") {
+    if (obj.spec_version.startsWith("3")) {
+      result.spec = "v3";
+      result.confidence = "high";
+      result.indicators.push(`spec_version "${obj.spec_version}" starts with "3"`);
+      return result;
+    }
+    if (obj.spec_version.startsWith("2")) {
+      result.spec = "v2";
+      result.confidence = "high";
+      result.indicators.push(`spec_version "${obj.spec_version}" starts with "2"`);
+      return result;
+    }
+  }
+  if (obj.spec_version === 2 || obj.spec_version === 2) {
+    result.spec = "v2";
+    result.confidence = "high";
+    result.indicators.push(`spec_version is numeric ${obj.spec_version}`);
+    return result;
+  }
+  if (dataObj) {
+    const v3Fields = [];
+    for (const field of V3_ONLY_FIELDS) {
+      if (field in dataObj) {
+        v3Fields.push(field);
+      }
+    }
+    if (v3Fields.length > 0) {
+      result.spec = "v3";
+      result.confidence = "medium";
+      result.indicators.push(`Has V3-only fields: ${v3Fields.join(", ")}`);
+      return result;
+    }
+  }
+  const rootV3Fields = [];
+  for (const field of V3_ONLY_FIELDS) {
+    if (field in obj) {
+      rootV3Fields.push(field);
+    }
+  }
+  if (rootV3Fields.length > 0) {
+    result.spec = "v3";
+    result.confidence = "medium";
+    result.indicators.push(`Has V3-only fields at root: ${rootV3Fields.join(", ")}`);
+    result.warnings.push("V3 fields found at root level instead of data object");
+    return result;
+  }
+  if (obj.spec && dataObj) {
+    const dataName = dataObj.name;
+    if (dataName && typeof dataName === "string") {
+      if (typeof obj.spec === "string") {
+        if (obj.spec.includes("v3") || obj.spec.includes("3")) {
+          result.spec = "v3";
+          result.confidence = "medium";
+          result.indicators.push(`spec field "${obj.spec}" contains "v3" or "3"`);
+          return result;
+        }
+        if (obj.spec.includes("v2") || obj.spec.includes("2")) {
+          result.spec = "v2";
+          result.confidence = "medium";
+          result.indicators.push(`spec field "${obj.spec}" contains "v2" or "2"`);
+          return result;
+        }
+      }
+      result.spec = "v3";
+      result.confidence = "medium";
+      result.indicators.push("Has wrapped format with spec and data.name");
+      return result;
+    }
+  }
+  if (obj.name && typeof obj.name === "string") {
+    if ("description" in obj || "personality" in obj || "scenario" in obj) {
+      result.spec = "v2";
+      result.confidence = "medium";
+      result.indicators.push("Unwrapped format with name, description/personality/scenario");
+      return result;
+    }
+  }
+  if (dataObj && typeof dataObj.name === "string") {
+    if ("description" in dataObj || "personality" in dataObj) {
+      result.spec = "v2";
+      result.confidence = "low";
+      result.indicators.push("Has data object with name and card fields, but no spec");
+      result.warnings.push("Missing spec field");
+      return result;
+    }
+  }
+  result.indicators.push("No card structure detected");
+  return result;
+}
+function hasLorebook(data) {
+  if (!data || typeof data !== "object") return false;
+  const obj = data;
+  const wrapped = obj.data;
+  if (wrapped?.character_book) {
+    const book = wrapped.character_book;
+    if (Array.isArray(book.entries) && book.entries.length > 0) return true;
+  }
+  if (obj.character_book) {
+    const book = obj.character_book;
+    if (Array.isArray(book.entries) && book.entries.length > 0) return true;
+  }
+  return false;
+}
+function looksLikeCard(data) {
+  if (!data || typeof data !== "object") return false;
+  const obj = data;
+  if (obj.spec === "chara_card_v2" || obj.spec === "chara_card_v3") {
+    return true;
+  }
+  if (obj.data && typeof obj.data === "object") {
+    const dataObj = obj.data;
+    if (typeof dataObj.name === "string" && dataObj.name.length > 0) {
+      return true;
+    }
+  }
+  if (typeof obj.name === "string" && obj.name.length > 0) {
+    if ("description" in obj || "personality" in obj || "first_mes" in obj) {
+      return true;
+    }
+  }
+  return false;
+}
+var POSITION_MAP = {
+  0: "before_char",
+  1: "after_char"
+};
+var V3_ONLY_ENTRY_FIELDS = [
+  "probability",
+  "depth",
+  "group",
+  "scan_frequency",
+  "use_regex",
+  "selective_logic",
+  "role",
+  "automation_id"
+];
+var V2_REQUIRED_DEFAULTS = {
+  name: "",
+  description: "",
+  personality: "",
+  scenario: "",
+  first_mes: "",
+  mes_example: ""
+};
+var V3_REQUIRED_DEFAULTS = {
+  name: "",
+  description: "",
+  personality: "",
+  scenario: "",
+  first_mes: "",
+  mes_example: "",
+  creator: "",
+  character_version: "1.0",
+  tags: [],
+  group_only_greetings: []
+};
+var DATA_FIELDS = [
+  "name",
+  "description",
+  "personality",
+  "scenario",
+  "first_mes",
+  "mes_example",
+  "creator_notes",
+  "system_prompt",
+  "post_history_instructions",
+  "alternate_greetings",
+  "character_book",
+  "tags",
+  "creator",
+  "character_version",
+  "extensions",
+  "assets",
+  "nickname",
+  "creator_notes_multilingual",
+  "source",
+  "creation_date",
+  "modification_date",
+  "group_only_greetings"
+];
+function deepClone(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = deepClone(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function isMilliseconds(timestamp) {
+  return timestamp > 1e10;
+}
+var CardNormalizer = {
+  /**
+   * Normalize card data to valid schema format.
+   *
+   * Handles:
+   * - Fixing spec/spec_version values
+   * - Moving misplaced fields to correct locations
+   * - Adding missing required fields with defaults
+   * - Handling hybrid formats (fields at root AND in data object)
+   *
+   * @param data - Raw card data (potentially malformed)
+   * @param spec - Target spec version
+   * @returns Normalized card data (does not mutate input)
+   */
+  normalize(data, spec) {
+    if (!data || typeof data !== "object") {
+      if (spec === "v3") {
+        return {
+          spec: "chara_card_v3",
+          spec_version: "3.0",
+          data: { ...V3_REQUIRED_DEFAULTS }
+        };
+      }
+      return {
+        spec: "chara_card_v2",
+        spec_version: "2.0",
+        data: { ...V2_REQUIRED_DEFAULTS }
+      };
+    }
+    const obj = data;
+    const result = {};
+    const existingData = obj.data && typeof obj.data === "object" ? obj.data : {};
+    const mergedData = {};
+    for (const [key, value] of Object.entries(existingData)) {
+      mergedData[key] = deepClone(value);
+    }
+    for (const field of DATA_FIELDS) {
+      if (field in obj && !(field in mergedData)) {
+        mergedData[field] = deepClone(obj[field]);
+      }
+    }
+    if (mergedData.character_book === null) {
+      delete mergedData.character_book;
+    }
+    if (mergedData.character_book && typeof mergedData.character_book === "object") {
+      mergedData.character_book = this.normalizeCharacterBook(
+        mergedData.character_book,
+        spec
+      );
+    }
+    const defaults = spec === "v3" ? V3_REQUIRED_DEFAULTS : V2_REQUIRED_DEFAULTS;
+    for (const [key, defaultValue] of Object.entries(defaults)) {
+      if (!(key in mergedData) || mergedData[key] === void 0) {
+        mergedData[key] = Array.isArray(defaultValue) ? [...defaultValue] : defaultValue;
+      }
+    }
+    if (mergedData.tags && !Array.isArray(mergedData.tags)) {
+      mergedData.tags = [];
+    }
+    if (mergedData.alternate_greetings && !Array.isArray(mergedData.alternate_greetings)) {
+      mergedData.alternate_greetings = [];
+    }
+    if (spec === "v3") {
+      if (mergedData.group_only_greetings && !Array.isArray(mergedData.group_only_greetings)) {
+        mergedData.group_only_greetings = [];
+      }
+    }
+    if (spec === "v3") {
+      result.spec = "chara_card_v3";
+      result.spec_version = "3.0";
+      result.data = this.fixTimestampsInner(mergedData);
+    } else {
+      result.spec = "chara_card_v2";
+      result.spec_version = "2.0";
+      result.data = mergedData;
+    }
+    return result;
+  },
+  /**
+   * Normalize a character book (lorebook).
+   *
+   * Handles:
+   * - Ensuring required fields exist
+   * - Converting numeric position values to string enums
+   * - Moving V3-only fields to extensions for V2 compatibility
+   *
+   * @param book - Raw character book data
+   * @param spec - Target spec version
+   * @returns Normalized character book
+   */
+  normalizeCharacterBook(book, spec) {
+    const result = {};
+    if (book.name !== void 0) result.name = book.name;
+    if (book.description !== void 0) result.description = book.description;
+    if (book.scan_depth !== void 0) result.scan_depth = book.scan_depth;
+    if (book.token_budget !== void 0) result.token_budget = book.token_budget;
+    if (book.recursive_scanning !== void 0)
+      result.recursive_scanning = book.recursive_scanning;
+    if (book.extensions !== void 0) result.extensions = deepClone(book.extensions);
+    const entries = Array.isArray(book.entries) ? book.entries : [];
+    result.entries = entries.map(
+      (entry) => this.normalizeEntry(entry, spec)
+    );
+    return result;
+  },
+  /**
+   * Normalize a single lorebook entry.
+   *
+   * Handles:
+   * - Converting numeric position to string enum
+   * - Moving V3-only fields to extensions for V2
+   * - Ensuring required fields exist
+   *
+   * @param entry - Raw entry data
+   * @param spec - Target spec version
+   * @returns Normalized entry
+   */
+  normalizeEntry(entry, spec) {
+    const result = {};
+    result.keys = Array.isArray(entry.keys) ? [...entry.keys] : [];
+    result.content = typeof entry.content === "string" ? entry.content : "";
+    result.enabled = entry.enabled !== false;
+    result.insertion_order = typeof entry.insertion_order === "number" ? entry.insertion_order : 0;
+    if (spec === "v2") {
+      result.extensions = entry.extensions && typeof entry.extensions === "object" ? deepClone(entry.extensions) : {};
+    }
+    if (entry.case_sensitive !== void 0) result.case_sensitive = entry.case_sensitive;
+    if (entry.name !== void 0) result.name = entry.name;
+    if (entry.priority !== void 0) result.priority = entry.priority;
+    if (entry.id !== void 0) result.id = entry.id;
+    if (entry.comment !== void 0) result.comment = entry.comment;
+    if (entry.selective !== void 0) result.selective = entry.selective;
+    if (entry.secondary_keys !== void 0) {
+      result.secondary_keys = Array.isArray(entry.secondary_keys) ? [...entry.secondary_keys] : [];
+    }
+    if (entry.constant !== void 0) result.constant = entry.constant;
+    if (entry.position !== void 0) {
+      if (typeof entry.position === "number") {
+        result.position = POSITION_MAP[entry.position] || "before_char";
+      } else if (entry.position === "before_char" || entry.position === "after_char") {
+        result.position = entry.position;
+      }
+    }
+    if (spec === "v3") {
+      if (entry.extensions !== void 0) result.extensions = deepClone(entry.extensions);
+      for (const field of V3_ONLY_ENTRY_FIELDS) {
+        if (entry[field] !== void 0) {
+          result[field] = entry[field];
+        }
+      }
+    } else {
+      const ext = result.extensions || {};
+      for (const field of V3_ONLY_ENTRY_FIELDS) {
+        if (entry[field] !== void 0) {
+          ext[field] = entry[field];
+        }
+      }
+      result.extensions = ext;
+    }
+    return result;
+  },
+  /**
+   * Fix CharacterTavern timestamp format (milliseconds -> seconds).
+   *
+   * CCv3 spec requires timestamps in seconds (Unix epoch).
+   * CharacterTavern exports timestamps in milliseconds.
+   *
+   * @param data - V3 card data
+   * @returns Card data with fixed timestamps (does not mutate input)
+   */
+  fixTimestamps(data) {
+    const result = deepClone(data);
+    result.data = this.fixTimestampsInner(
+      result.data
+    );
+    return result;
+  },
+  /**
+   * Internal: fix timestamps in data object
+   */
+  fixTimestampsInner(data) {
+    const result = { ...data };
+    if (typeof result.creation_date === "number" && isMilliseconds(result.creation_date)) {
+      result.creation_date = Math.floor(result.creation_date / 1e3);
+    }
+    if (typeof result.modification_date === "number" && isMilliseconds(result.modification_date)) {
+      result.modification_date = Math.floor(result.modification_date / 1e3);
+    }
+    return result;
+  },
+  /**
+   * Auto-detect spec and normalize.
+   *
+   * @param data - Raw card data
+   * @returns Normalized card data, or null if not a valid card
+   */
+  autoNormalize(data) {
+    const spec = detectSpec(data);
+    if (!spec) return null;
+    const targetSpec = spec === "v3" ? "v3" : "v2";
+    return this.normalize(data, targetSpec);
+  }
+};
+function zodErrorToMessage(zodError, context) {
+  const messages = zodError.errors.map((err) => {
+    const path = err.path.length > 0 ? `${err.path.join(".")}: ` : "";
+    return `${path}${err.message}`;
+  });
+  const message = messages.join("; ");
+  return context ? `${context} - ${message}` : message;
+}
+function getFirstErrorField(zodError) {
+  return zodError.errors[0]?.path[0]?.toString();
+}
+function safeParse(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    error: zodErrorToMessage(result.error),
+    field: getFirstErrorField(result.error)
+  };
+}
+//# sourceMappingURL=schemas.cjs.map