@character-foundry/character-foundry 0.4.3-dev.1766103111 → 0.4.3

package/dist/loader.cjs

@@ -21,7 +21,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var loader_exports = {};
 __export(loader_exports, {
   computeContentHash: () => computeContentHash,
-  computeContentHashV2: () => computeContentHashV2,
   detectFormat: () => detectFormat,
   getContainerFormat: () => getContainerFormat,
   mightBeCard: () => mightBeCard,
@@ -444,58 +443,6 @@ var import_zod = require("zod");
 var import_zod2 = require("zod");
 var import_zod3 = require("zod");
 var import_zod4 = require("zod");
-function preprocessTimestamp(val) {
-  if (val === null || val === void 0) return void 0;
-  let num;
-  if (typeof val === "number") {
-    num = val;
-  } else if (typeof val === "string") {
-    const trimmed = val.trim();
-    if (!trimmed) return void 0;
-    const parsed = Number(trimmed);
-    if (!isNaN(parsed)) {
-      num = parsed;
-    } else {
-      const date = new Date(trimmed);
-      if (isNaN(date.getTime())) return void 0;
-      num = Math.floor(date.getTime() / 1e3);
-    }
-  } else {
-    return void 0;
-  }
-  if (num > 1e10) {
-    num = Math.floor(num / 1e3);
-  }
-  if (num < 0) return void 0;
-  return num;
-}
-function preprocessNumeric(val) {
-  if (val === null || val === void 0) return void 0;
-  if (typeof val === "number") {
-    return isNaN(val) ? void 0 : val;
-  }
-  if (typeof val === "string") {
-    const trimmed = val.trim();
-    if (!trimmed) return void 0;
-    const parsed = Number(trimmed);
-    return isNaN(parsed) ? void 0 : parsed;
-  }
-  return void 0;
-}
-var KNOWN_ASSET_TYPES = /* @__PURE__ */ new Set([
-  "icon",
-  "background",
-  "emotion",
-  "user_icon",
-  "sound",
-  "video",
-  "custom",
-  "x-risu-asset"
-]);
-function preprocessAssetType(val) {
-  if (typeof val !== "string") return "custom";
-  return KNOWN_ASSET_TYPES.has(val) ? val : "custom";
-}
 var ISO8601Schema = import_zod.z.string().datetime();
 var UUIDSchema = import_zod.z.string().uuid();
 var SpecSchema = import_zod.z.enum(["v2", "v3"]);
@@ -518,19 +465,16 @@ var SourceFormatSchema = import_zod.z.enum([
   // VoxPkg format
 ]);
 var OriginalShapeSchema = import_zod.z.enum(["wrapped", "unwrapped", "legacy"]);
-var AssetTypeSchema = import_zod.z.preprocess(
-  preprocessAssetType,
-  import_zod.z.enum([
-    "icon",
-    "background",
-    "emotion",
-    "user_icon",
-    "sound",
-    "video",
-    "custom",
-    "x-risu-asset"
-  ])
-);
+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(),
@@ -564,8 +508,8 @@ var CCv2LorebookEntrySchema = import_zod2.z.object({
 var CCv2CharacterBookSchema = import_zod2.z.object({
   name: import_zod2.z.string().optional(),
   description: import_zod2.z.string().optional(),
-  scan_depth: import_zod2.z.preprocess(preprocessNumeric, import_zod2.z.number().int().nonnegative().optional()),
-  token_budget: import_zod2.z.preprocess(preprocessNumeric, import_zod2.z.number().int().nonnegative().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)
@@ -639,8 +583,8 @@ var CCv3LorebookEntrySchema = import_zod3.z.object({
 var CCv3CharacterBookSchema = import_zod3.z.object({
   name: import_zod3.z.string().optional(),
   description: import_zod3.z.string().optional(),
-  scan_depth: import_zod3.z.preprocess(preprocessNumeric, import_zod3.z.number().int().nonnegative().optional()),
-  token_budget: import_zod3.z.preprocess(preprocessNumeric, import_zod3.z.number().int().nonnegative().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)
@@ -672,9 +616,10 @@ var CCv3DataInnerSchema = import_zod3.z.object({
   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(),
-  // Unix timestamps - preprocess to handle ISO strings, numeric strings, milliseconds
-  creation_date: import_zod3.z.preprocess(preprocessTimestamp, import_zod3.z.number().int().nonnegative().optional()),
-  modification_date: import_zod3.z.preprocess(preprocessTimestamp, import_zod3.z.number().int().nonnegative().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"),
@@ -8782,7 +8727,7 @@ function defaultTokenCounter(_card) {
     total: 0
   };
 }
-function getCanonicalContentV1(card) {
+function getCanonicalContent(card) {
   const normalized = {
     name: card.data.name,
     description: card.data.description || "",
@@ -8804,69 +8749,6 @@ function getCanonicalContentV1(card) {
   };
   return JSON.stringify(normalized, Object.keys(normalized).sort());
 }
-function stableStringify(value) {
-  if (value === null) return "null";
-  switch (typeof value) {
-    case "string":
-      return JSON.stringify(value);
-    case "number":
-      return Number.isFinite(value) ? String(value) : "null";
-    case "boolean":
-      return value ? "true" : "false";
-    case "bigint":
-      return JSON.stringify(value.toString());
-    case "undefined":
-    case "function":
-    case "symbol":
-      return "null";
-    case "object": {
-      if (Array.isArray(value)) {
-        const parts2 = value.map((item) => {
-          if (item === void 0 || typeof item === "function" || typeof item === "symbol") {
-            return "null";
-          }
-          return stableStringify(item);
-        });
-        return `[${parts2.join(",")}]`;
-      }
-      const obj = value;
-      const keys = Object.keys(obj).sort();
-      const parts = [];
-      for (const key of keys) {
-        const v = obj[key];
-        if (v === void 0 || typeof v === "function" || typeof v === "symbol") {
-          continue;
-        }
-        parts.push(`${JSON.stringify(key)}:${stableStringify(v)}`);
-      }
-      return `{${parts.join(",")}}`;
-    }
-    default:
-      return "null";
-  }
-}
-function getCanonicalContentV2(card) {
-  const normalized = {
-    name: card.data.name,
-    description: card.data.description || "",
-    personality: card.data.personality || "",
-    scenario: card.data.scenario || "",
-    first_mes: card.data.first_mes || "",
-    mes_example: card.data.mes_example || "",
-    system_prompt: card.data.system_prompt || "",
-    post_history_instructions: card.data.post_history_instructions || "",
-    alternate_greetings: card.data.alternate_greetings || [],
-    character_book: card.data.character_book ? {
-      entries: (card.data.character_book.entries || []).map((e) => ({
-        keys: e.keys,
-        content: e.content,
-        enabled: e.enabled
-      }))
-    } : null,
-    creator_notes: card.data.creator_notes || ""
-  };
-  return stableStringify(normalized);
-}
 function isWithinTolerance(clientValue, computedValue, tolerance) {
   if (clientValue === void 0) return false;
   if (computedValue === 0) return clientValue === 0;
@@ -8887,18 +8769,15 @@ async function validateClientMetadata(clientMetadata, parseResult, options = {})
   const warnings = [];
   const errors = [];
   const computedTokens = countTokens(card);
-  const canonicalContentV1 = getCanonicalContentV1(card);
-  const canonicalContentV2 = getCanonicalContentV2(card);
-  const computedHashV1 = await computeHash(canonicalContentV1);
-  const computedHashV2 = await computeHash(canonicalContentV2);
+  const canonicalContent = getCanonicalContent(card);
+  const computedHash = await computeHash(canonicalContent);
   const entries = card.data.character_book?.entries || [];
   const computedHasLorebook = entries.length > 0;
   const computedLorebookCount = entries.length;
   const authoritative = {
     name: card.data.name,
     tokens: computedTokens,
-    contentHash: computedHashV1,
-    contentHashV2: computedHashV2,
+    contentHash: computedHash,
     hasLorebook: computedHasLorebook,
     lorebookEntriesCount: computedLorebookCount
   };
@@ -8910,27 +8789,21 @@ async function validateClientMetadata(clientMetadata, parseResult, options = {})
       withinTolerance: false
     });
   }
-  const matchesV1 = clientMetadata.contentHash === computedHashV1;
-  const matchesV2 = clientMetadata.contentHash === computedHashV2;
-  if (!matchesV1 && !matchesV2) {
+  if (clientMetadata.contentHash !== computedHash) {
     const disc = {
       field: "contentHash",
       clientValue: clientMetadata.contentHash,
-      computedValue: computedHashV1,
+      computedValue: computedHash,
       withinTolerance: false
     };
     discrepancies.push(disc);
     if (allowHashMismatch) {
       warnings.push(
-        `Content hash mismatch: client=${clientMetadata.contentHash.substring(0, 8)}..., server(v1)=${computedHashV1.substring(0, 8)}..., server(v2)=${computedHashV2.substring(0, 8)}...`
+        `Content hash mismatch: client=${clientMetadata.contentHash.substring(0, 8)}..., server=${computedHash.substring(0, 8)}...`
       );
     } else {
       errors.push("Content hash mismatch - possible tampering or encoding difference");
     }
-  } else if (matchesV1 && !matchesV2) {
-    warnings.push(
-      "Client contentHash matches legacy v1 canonicalization. Prefer authoritative.contentHashV2 for new storage."
-    );
   }
   const tokenFields = [
     "description",
@@ -9011,11 +8884,7 @@ async function validateClientMetadata(clientMetadata, parseResult, options = {})
   };
 }
 async function computeContentHash(card) {
-  const content = getCanonicalContentV1(card);
-  return sha256Hash(content);
-}
-async function computeContentHashV2(card) {
-  const content = getCanonicalContentV2(card);
+  const content = getCanonicalContent(card);
   return sha256Hash(content);
 }
 function validateClientMetadataSync(clientMetadata, parseResult, options) {
@@ -9031,18 +8900,15 @@ function validateClientMetadataSync(clientMetadata, parseResult, options) {
   const warnings = [];
   const errors = [];
   const computedTokens = countTokens(card);
-  const canonicalContentV1 = getCanonicalContentV1(card);
-  const canonicalContentV2 = getCanonicalContentV2(card);
-  const computedHashV1 = computeHash(canonicalContentV1);
-  const computedHashV2 = computeHash(canonicalContentV2);
+  const canonicalContent = getCanonicalContent(card);
+  const computedHash = computeHash(canonicalContent);
   const entries = card.data.character_book?.entries || [];
   const computedHasLorebook = entries.length > 0;
   const computedLorebookCount = entries.length;
   const authoritative = {
     name: card.data.name,
     tokens: computedTokens,
-    contentHash: computedHashV1,
-    contentHashV2: computedHashV2,
+    contentHash: computedHash,
     hasLorebook: computedHasLorebook,
     lorebookEntriesCount: computedLorebookCount
   };
@@ -9054,13 +8920,11 @@ function validateClientMetadataSync(clientMetadata, parseResult, options) {
       withinTolerance: false
     });
   }
-  const matchesV1 = clientMetadata.contentHash === computedHashV1;
-  const matchesV2 = clientMetadata.contentHash === computedHashV2;
-  if (!matchesV1 && !matchesV2) {
+  if (clientMetadata.contentHash !== computedHash) {
     discrepancies.push({
       field: "contentHash",
       clientValue: clientMetadata.contentHash,
-      computedValue: computedHashV1,
+      computedValue: computedHash,
       withinTolerance: false
     });
     if (allowHashMismatch) {
@@ -9068,10 +8932,6 @@ function validateClientMetadataSync(clientMetadata, parseResult, options) {
     } else {
       errors.push("Content hash mismatch");
     }
-  } else if (matchesV1 && !matchesV2) {
-    warnings.push(
-      "Client contentHash matches legacy v1 canonicalization. Prefer authoritative.contentHashV2 for new storage."
-    );
   }
   const tokenFields = [
     "description",