@character-foundry/character-foundry 0.1.8 → 0.1.9-dev.1765932375

package/dist/index.js

@@ -104,7 +104,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;
@@ -564,22 +580,24 @@ var ExtractedAssetSchema = z.object({
   mimeType: z.string()
 });
 var CCv2LorebookEntrySchema = z2.object({
-  keys: z2.array(z2.string()),
+  keys: z2.array(z2.string()).optional(),
+  // Some tools use 'key' instead
   content: z2.string(),
-  enabled: z2.boolean(),
-  insertion_order: z2.number().int(),
-  // Optional fields
+  enabled: z2.boolean().default(true),
+  // Default to enabled if missing
+  insertion_order: z2.number().int().default(0),
+  // Optional fields - be lenient with nulls since wild data has them
   extensions: z2.record(z2.unknown()).optional(),
-  case_sensitive: z2.boolean().optional(),
+  case_sensitive: z2.boolean().nullable().optional(),
   name: z2.string().optional(),
   priority: z2.number().int().optional(),
   id: z2.number().int().optional(),
   comment: z2.string().optional(),
-  selective: z2.boolean().optional(),
+  selective: z2.boolean().nullable().optional(),
   secondary_keys: z2.array(z2.string()).optional(),
-  constant: z2.boolean().optional(),
-  position: z2.enum(["before_char", "after_char"]).optional()
-});
+  constant: z2.boolean().nullable().optional(),
+  position: z2.union([z2.enum(["before_char", "after_char"]), z2.number().int()]).nullable().optional()
+}).passthrough();
 var CCv2CharacterBookSchema = z2.object({
   name: z2.string().optional(),
   description: z2.string().optional(),
@@ -627,31 +645,34 @@ function getV2Data(card) {
   return card;
 }
 var CCv3LorebookEntrySchema = z3.object({
-  keys: z3.array(z3.string()),
+  keys: z3.array(z3.string()).optional(),
+  // Some tools use 'key' instead
   content: z3.string(),
-  enabled: z3.boolean(),
-  insertion_order: z3.number().int(),
-  // Optional fields
-  case_sensitive: z3.boolean().optional(),
+  enabled: z3.boolean().default(true),
+  // Default to enabled if missing
+  insertion_order: z3.number().int().default(0),
+  // Optional fields - be lenient with nulls since wild data has them
+  case_sensitive: z3.boolean().nullable().optional(),
   name: z3.string().optional(),
   priority: z3.number().int().optional(),
   id: z3.number().int().optional(),
   comment: z3.string().optional(),
-  selective: z3.boolean().optional(),
+  selective: z3.boolean().nullable().optional(),
   secondary_keys: z3.array(z3.string()).optional(),
-  constant: z3.boolean().optional(),
-  position: z3.enum(["before_char", "after_char"]).optional(),
+  constant: z3.boolean().nullable().optional(),
+  position: z3.union([z3.enum(["before_char", "after_char"]), z3.number().int()]).nullable().optional(),
   extensions: z3.record(z3.unknown()).optional(),
-  // v3 specific
+  // v3 specific - also lenient with types since SillyTavern uses numbers for enums
   automation_id: z3.string().optional(),
-  role: z3.enum(["system", "user", "assistant"]).optional(),
+  role: z3.union([z3.enum(["system", "user", "assistant"]), z3.number().int()]).nullable().optional(),
   group: z3.string().optional(),
   scan_frequency: z3.number().int().nonnegative().optional(),
-  probability: z3.number().min(0).max(1).optional(),
+  probability: z3.number().min(0).max(100).optional(),
+  // Some tools use 0-100 instead of 0-1
   use_regex: z3.boolean().optional(),
   depth: z3.number().int().nonnegative().optional(),
-  selective_logic: z3.enum(["AND", "NOT"]).optional()
-});
+  selective_logic: z3.union([z3.enum(["AND", "NOT"]), z3.number().int()]).optional()
+}).passthrough();
 var CCv3CharacterBookSchema = z3.object({
   name: z3.string().optional(),
   description: z3.string().optional(),
@@ -8329,6 +8350,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 || [],
@@ -8344,7 +8370,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) {
@@ -8507,6 +8533,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);
 }
@@ -8574,39 +8637,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);
@@ -8653,13 +8699,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 {