@character-foundry/character-foundry 0.1.9 → 0.4.0-dev.1765937896

package/dist/loader.cjs

@@ -134,7 +134,23 @@ function streamingUnzipSync(data, limits = DEFAULT_ZIP_LIMITS) {
       if (unsafePathHandling === "warn" && limits.onUnsafePath) {
         limits.onUnsafePath(file.name, reason);
       }
-      file.ondata = () => {
+      file.ondata = (err, chunk, _final) => {
+        if (error) return;
+        if (err) {
+          error = err;
+          return;
+        }
+        if (chunk && chunk.length > 0) {
+          totalBytes += chunk.length;
+          if (totalBytes > limits.maxTotalSize) {
+            error = new ZipPreflightError(
+              `Total actual size ${totalBytes} exceeds limit ${limits.maxTotalSize}`,
+              totalBytes,
+              limits.maxTotalSize
+            );
+            file.terminate();
+          }
+        }
       };
       file.start();
       return;
@@ -471,22 +487,24 @@ var ExtractedAssetSchema = import_zod.z.object({
   mimeType: import_zod.z.string()
 });
 var CCv2LorebookEntrySchema = import_zod2.z.object({
-  keys: import_zod2.z.array(import_zod2.z.string()),
+  keys: import_zod2.z.array(import_zod2.z.string()).optional(),
+  // Some tools use 'key' instead
   content: import_zod2.z.string(),
-  enabled: import_zod2.z.boolean(),
-  insertion_order: import_zod2.z.number().int(),
-  // Optional fields
+  enabled: import_zod2.z.boolean().default(true),
+  // Default to enabled if missing
+  insertion_order: import_zod2.z.number().int().default(0),
+  // Optional fields - be lenient with nulls since wild data has them
   extensions: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  case_sensitive: import_zod2.z.boolean().optional(),
+  case_sensitive: import_zod2.z.boolean().nullable().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(),
+  selective: import_zod2.z.boolean().nullable().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()
-});
+  constant: import_zod2.z.boolean().nullable().optional(),
+  position: import_zod2.z.union([import_zod2.z.enum(["before_char", "after_char"]), import_zod2.z.number().int()]).nullable().optional()
+}).passthrough();
 var CCv2CharacterBookSchema = import_zod2.z.object({
   name: import_zod2.z.string().optional(),
   description: import_zod2.z.string().optional(),
@@ -534,31 +552,34 @@ function getV2Data(card) {
   return card;
 }
 var CCv3LorebookEntrySchema = import_zod3.z.object({
-  keys: import_zod3.z.array(import_zod3.z.string()),
+  keys: import_zod3.z.array(import_zod3.z.string()).optional(),
+  // Some tools use 'key' instead
   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(),
+  enabled: import_zod3.z.boolean().default(true),
+  // Default to enabled if missing
+  insertion_order: import_zod3.z.number().int().default(0),
+  // Optional fields - be lenient with nulls since wild data has them
+  case_sensitive: import_zod3.z.boolean().nullable().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(),
+  selective: import_zod3.z.boolean().nullable().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(),
+  constant: import_zod3.z.boolean().nullable().optional(),
+  position: import_zod3.z.union([import_zod3.z.enum(["before_char", "after_char"]), import_zod3.z.number().int()]).nullable().optional(),
   extensions: import_zod3.z.record(import_zod3.z.unknown()).optional(),
-  // v3 specific
+  // v3 specific - also lenient with types since SillyTavern uses numbers for enums
   automation_id: import_zod3.z.string().optional(),
-  role: import_zod3.z.enum(["system", "user", "assistant"]).optional(),
+  role: import_zod3.z.union([import_zod3.z.enum(["system", "user", "assistant"]), import_zod3.z.number().int()]).nullable().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(),
+  probability: import_zod3.z.number().min(0).max(100).optional(),
+  // Some tools use 0-100 instead of 0-1
   use_regex: import_zod3.z.boolean().optional(),
   depth: import_zod3.z.number().int().nonnegative().optional(),
-  selective_logic: import_zod3.z.enum(["AND", "NOT"]).optional()
-});
+  selective_logic: import_zod3.z.union([import_zod3.z.enum(["AND", "NOT"]), import_zod3.z.number().int()]).optional()
+}).passthrough();
 var CCv3CharacterBookSchema = import_zod3.z.object({
   name: import_zod3.z.string().optional(),
   description: import_zod3.z.string().optional(),
@@ -7719,8 +7740,10 @@ function voxtaToCCv3(character, books) {
       };
     }
   }
-  const creationDate = character.DateCreated ? Math.floor(new Date(character.DateCreated).getTime() / 1e3) : void 0;
-  const modificationDate = character.DateModified ? Math.floor(new Date(character.DateModified).getTime() / 1e3) : void 0;
+  const rawCreationDate = character.DateCreated ? Math.floor(new Date(character.DateCreated).getTime() / 1e3) : void 0;
+  const rawModificationDate = character.DateModified ? Math.floor(new Date(character.DateModified).getTime() / 1e3) : void 0;
+  const creationDate = rawCreationDate !== void 0 && rawCreationDate >= 0 ? rawCreationDate : void 0;
+  const modificationDate = rawModificationDate !== void 0 && rawModificationDate >= 0 ? rawModificationDate : void 0;
   const card = {
     spec: "chara_card_v3",
     spec_version: "3.0",
@@ -7755,6 +7778,11 @@ var DELTA_MAX_TOTAL_SIZE = 500 * 1024 * 1024;
 var DELTA_MAX_FILE_SIZE = 50 * 1024 * 1024;
 
 // ../normalizer/dist/index.js
+function normalizePosition(position) {
+  if (position === void 0 || position === null) return "before_char";
+  if (typeof position === "string") return position;
+  return position;
+}
 function convertLorebookEntry(entry, index) {
   return {
     keys: entry.keys || [],
@@ -7770,7 +7798,7 @@ function convertLorebookEntry(entry, index) {
     selective: entry.selective ?? false,
     secondary_keys: entry.secondary_keys || [],
     constant: entry.constant ?? false,
-    position: entry.position || "before_char"
+    position: normalizePosition(entry.position)
   };
 }
 function convertCharacterBook(book) {
@@ -8182,6 +8210,43 @@ var DEFAULT_OPTIONS3 = {
   maxTotalSize: 500 * 1024 * 1024,
   extractAssets: true
 };
+var ASSET_PREFIX_VARIANTS = [
+  { prefix: "__asset:", format: "CCv3 (SillyTavern)" },
+  { prefix: "asset:", format: "CCv2/CCv3 common" },
+  { prefix: "pngchunk:", format: "Explicit PNG chunk" },
+  { prefix: "chara-ext-asset_:", format: "RisuAI (with colon)" },
+  { prefix: "chara-ext-asset_", format: "RisuAI" },
+  { prefix: "__asset_", format: "Legacy underscore variant" }
+];
+function isChunkReference(uri) {
+  return ASSET_PREFIX_VARIANTS.some(({ prefix }) => uri.startsWith(prefix)) || !uri.includes(":");
+}
+function stripAssetPrefix(uri) {
+  for (const { prefix } of ASSET_PREFIX_VARIANTS) {
+    if (uri.startsWith(prefix)) {
+      return uri.substring(prefix.length);
+    }
+  }
+  return uri;
+}
+function generateChunkKeyCandidates(assetId, originalUri) {
+  return [
+    assetId,
+    // Plain ID: "0"
+    originalUri,
+    // Original URI: "__asset:0"
+    `asset:${assetId}`,
+    // Common format
+    `__asset:${assetId}`,
+    // CCv3 format
+    `__asset_${assetId}`,
+    // Legacy underscore variant
+    `chara-ext-asset_${assetId}`,
+    // RisuAI format
+    `chara-ext-asset_:${assetId}`
+    // RisuAI format with colon
+  ];
+}
 function estimateBase64DecodedSize(base64Length) {
   return Math.ceil(base64Length * 0.75);
 }
@@ -8249,39 +8314,22 @@ function parsePng(data, options) {
   if (extracted.extraChunks && options.extractAssets && card.data.assets) {
     const usedChunks = /* @__PURE__ */ new Set();
     const chunkMap = /* @__PURE__ */ new Map();
+    const risuIndexPrefixes = ASSET_PREFIX_VARIANTS.filter((v) => v.prefix.startsWith("chara-ext-asset_"));
     for (const chunk of extracted.extraChunks) {
       chunkMap.set(chunk.keyword, chunk);
-      if (chunk.keyword.startsWith("chara-ext-asset_")) {
-        const suffix = chunk.keyword.replace("chara-ext-asset_", "");
-        chunkMap.set(suffix, chunk);
-        if (suffix.startsWith(":")) {
-          chunkMap.set(suffix.substring(1), chunk);
+      for (const { prefix } of risuIndexPrefixes) {
+        if (chunk.keyword.startsWith(prefix)) {
+          const suffix = chunk.keyword.substring(prefix.length);
+          chunkMap.set(suffix, chunk);
+          break;
         }
       }
     }
     for (const descriptor of card.data.assets) {
       if (!descriptor.uri) continue;
-      if (descriptor.uri.startsWith("__asset:") || descriptor.uri.startsWith("asset:") || descriptor.uri.startsWith("pngchunk:") || !descriptor.uri.includes(":")) {
-        let assetId = descriptor.uri;
-        if (assetId.startsWith("__asset:")) assetId = assetId.substring(8);
-        else if (assetId.startsWith("asset:")) assetId = assetId.substring(6);
-        else if (assetId.startsWith("pngchunk:")) assetId = assetId.substring(9);
-        const candidates = [
-          assetId,
-          // "0"
-          descriptor.uri,
-          // "__asset:0"
-          `asset:${assetId}`,
-          // "asset:0"
-          `__asset:${assetId}`,
-          // "__asset:0"
-          `__asset_${assetId}`,
-          // "__asset_0"
-          `chara-ext-asset_${assetId}`,
-          // "chara-ext-asset_0"
-          `chara-ext-asset_:${assetId}`
-          // "chara-ext-asset_:0"
-        ];
+      if (isChunkReference(descriptor.uri)) {
+        const assetId = stripAssetPrefix(descriptor.uri);
+        const candidates = generateChunkKeyCandidates(assetId, descriptor.uri);
         let chunk;
         for (const candidate of candidates) {
           chunk = chunkMap.get(candidate);
@@ -8328,13 +8376,15 @@ function parsePng(data, options) {
         }
       }
     }
+    const risuPrefixes = ASSET_PREFIX_VARIANTS.filter((v) => v.prefix.startsWith("chara-ext-asset_"));
     for (const chunk of extracted.extraChunks) {
       if (!usedChunks.has(chunk.keyword)) {
         let assetId = null;
-        if (chunk.keyword.startsWith("chara-ext-asset_:")) {
-          assetId = chunk.keyword.substring("chara-ext-asset_:".length);
-        } else if (chunk.keyword.startsWith("chara-ext-asset_")) {
-          assetId = chunk.keyword.substring("chara-ext-asset_".length);
+        for (const { prefix } of risuPrefixes) {
+          if (chunk.keyword.startsWith(prefix)) {
+            assetId = chunk.keyword.substring(prefix.length);
+            break;
+          }
         }
         if (assetId) {
           try {