@character-foundry/character-foundry 0.1.3 → 0.1.5

package/dist/charx.js

@@ -1,2 +1,894 @@
-export * from '@character-foundry/charx';
+// ../core/dist/index.js
+function fromString(str) {
+  return new TextEncoder().encode(str);
+}
+function toString(data) {
+  return new TextDecoder().decode(data);
+}
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+function decode(base64) {
+  if (isNode) {
+    return new Uint8Array(Buffer.from(base64, "base64"));
+  }
+  const binary = atob(base64);
+  const result = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    result[i] = binary.charCodeAt(i);
+  }
+  return result;
+}
+var ENCODE_CHUNK_SIZE = 64 * 1024;
+var FOUNDRY_ERROR_MARKER = /* @__PURE__ */ Symbol.for("@character-foundry/core:FoundryError");
+var FoundryError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FoundryError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /** @internal Marker for cross-module identification */
+  [FOUNDRY_ERROR_MARKER] = true;
+};
+var ParseError = class extends FoundryError {
+  constructor(message, format) {
+    super(message, "PARSE_ERROR");
+    this.format = format;
+    this.name = "ParseError";
+  }
+};
+var SizeLimitError = class extends FoundryError {
+  constructor(actualSize, maxSize, context) {
+    const actualMB = (actualSize / 1024 / 1024).toFixed(2);
+    const maxMB = (maxSize / 1024 / 1024).toFixed(2);
+    const msg = context ? `${context}: Size ${actualMB}MB exceeds limit ${maxMB}MB` : `Size ${actualMB}MB exceeds limit ${maxMB}MB`;
+    super(msg, "SIZE_LIMIT_EXCEEDED");
+    this.actualSize = actualSize;
+    this.maxSize = maxSize;
+    this.name = "SizeLimitError";
+  }
+};
+function normalizeURI(uri) {
+  const trimmed = uri.trim();
+  if (trimmed.startsWith("embedded://")) {
+    return "embeded://" + trimmed.substring("embedded://".length);
+  }
+  if (trimmed.startsWith("__asset:")) {
+    const id = trimmed.substring("__asset:".length);
+    return `pngchunk:${id}`;
+  }
+  if (trimmed.startsWith("asset:")) {
+    const id = trimmed.substring("asset:".length);
+    return `pngchunk:${id}`;
+  }
+  if (trimmed.startsWith("chara-ext-asset_:")) {
+    const id = trimmed.substring("chara-ext-asset_:".length);
+    return `pngchunk:${id}`;
+  }
+  if (trimmed.startsWith("chara-ext-asset_")) {
+    const id = trimmed.substring("chara-ext-asset_".length);
+    return `pngchunk:${id}`;
+  }
+  return trimmed;
+}
+function parseURI(uri) {
+  const trimmed = uri.trim();
+  const normalized = normalizeURI(trimmed);
+  if (trimmed.startsWith("__asset:") || trimmed.startsWith("asset:") || trimmed.startsWith("chara-ext-asset_") || trimmed.startsWith("pngchunk:")) {
+    let assetId;
+    if (trimmed.startsWith("__asset:")) {
+      assetId = trimmed.substring("__asset:".length);
+    } else if (trimmed.startsWith("asset:")) {
+      assetId = trimmed.substring("asset:".length);
+    } else if (trimmed.startsWith("chara-ext-asset_:")) {
+      assetId = trimmed.substring("chara-ext-asset_:".length);
+    } else if (trimmed.startsWith("pngchunk:")) {
+      assetId = trimmed.substring("pngchunk:".length);
+    } else {
+      assetId = trimmed.substring("chara-ext-asset_".length);
+    }
+    const candidates = [
+      assetId,
+      // "0" or "filename.png"
+      trimmed,
+      // Original URI
+      `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"
+      `pngchunk:${assetId}`
+      // "pngchunk:0"
+    ];
+    return {
+      scheme: "pngchunk",
+      originalUri: uri,
+      normalizedUri: normalized,
+      chunkKey: assetId,
+      chunkCandidates: candidates
+    };
+  }
+  if (trimmed === "ccdefault:" || trimmed.startsWith("ccdefault:")) {
+    return {
+      scheme: "ccdefault",
+      originalUri: uri,
+      normalizedUri: normalized
+    };
+  }
+  if (trimmed.startsWith("embeded://") || trimmed.startsWith("embedded://")) {
+    const path = trimmed.startsWith("embeded://") ? trimmed.substring("embeded://".length) : trimmed.substring("embedded://".length);
+    return {
+      scheme: "embeded",
+      originalUri: uri,
+      normalizedUri: normalized,
+      path
+    };
+  }
+  if (trimmed.startsWith("https://")) {
+    return {
+      scheme: "https",
+      originalUri: uri,
+      normalizedUri: normalized,
+      url: trimmed
+    };
+  }
+  if (trimmed.startsWith("http://")) {
+    return {
+      scheme: "http",
+      originalUri: uri,
+      normalizedUri: normalized,
+      url: trimmed
+    };
+  }
+  if (trimmed.startsWith("data:")) {
+    const parsed = parseDataURI(trimmed);
+    return {
+      scheme: "data",
+      originalUri: uri,
+      normalizedUri: normalized,
+      ...parsed
+    };
+  }
+  if (trimmed.startsWith("file://")) {
+    const path = trimmed.substring("file://".length);
+    return {
+      scheme: "file",
+      originalUri: uri,
+      normalizedUri: normalized,
+      path
+    };
+  }
+  if (/^[a-zA-Z0-9_-]+$/.test(trimmed)) {
+    return {
+      scheme: "internal",
+      originalUri: uri,
+      normalizedUri: normalized,
+      path: trimmed
+    };
+  }
+  return {
+    scheme: "unknown",
+    originalUri: uri,
+    normalizedUri: normalized
+  };
+}
+function parseDataURI(uri) {
+  const match = uri.match(/^data:([^;,]+)?(;base64)?,(.*)$/);
+  if (!match) {
+    return {};
+  }
+  return {
+    mimeType: match[1] || "text/plain",
+    encoding: match[2] ? "base64" : void 0,
+    data: match[3]
+  };
+}
+function getMimeTypeFromExt(ext) {
+  const extToMime = {
+    // Images
+    "png": "image/png",
+    "jpg": "image/jpeg",
+    "jpeg": "image/jpeg",
+    "webp": "image/webp",
+    "gif": "image/gif",
+    "avif": "image/avif",
+    "svg": "image/svg+xml",
+    "bmp": "image/bmp",
+    "ico": "image/x-icon",
+    // Audio
+    "mp3": "audio/mpeg",
+    "wav": "audio/wav",
+    "ogg": "audio/ogg",
+    "flac": "audio/flac",
+    "m4a": "audio/mp4",
+    "aac": "audio/aac",
+    // Video
+    "mp4": "video/mp4",
+    "webm": "video/webm",
+    "avi": "video/x-msvideo",
+    "mov": "video/quicktime",
+    "mkv": "video/x-matroska",
+    // Text/Data
+    "json": "application/json",
+    "txt": "text/plain",
+    "html": "text/html",
+    "css": "text/css",
+    "js": "application/javascript"
+  };
+  return extToMime[ext.toLowerCase()] || "application/octet-stream";
+}
+
+// ../core/dist/zip.js
+import { Unzip, UnzipInflate, UnzipPassThrough } from "fflate";
+function indexOf(data, search, fromIndex = 0) {
+  outer: for (let i = fromIndex; i <= data.length - search.length; i++) {
+    for (let j = 0; j < search.length; j++) {
+      if (data[i + j] !== search[j]) continue outer;
+    }
+    return i;
+  }
+  return -1;
+}
+function concat(...arrays) {
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+var ZIP_SIGNATURE = new Uint8Array([80, 75, 3, 4]);
+var JPEG_SIGNATURE = new Uint8Array([255, 216, 255]);
+var DEFAULT_ZIP_LIMITS = {
+  maxFileSize: 50 * 1024 * 1024,
+  // 50MB per file (Risu standard)
+  maxTotalSize: 500 * 1024 * 1024,
+  // 500MB total (CharX can have many expression assets)
+  maxFiles: 1e4,
+  // CharX cards can have 2k+ expression assets
+  unsafePathHandling: "skip"
+  // Backwards compatible default
+};
+function isJPEG(data) {
+  return data.length >= 3 && data[0] === 255 && data[1] === 216 && data[2] === 255;
+}
+function isJpegCharX(data) {
+  if (!isJPEG(data)) return false;
+  return indexOf(data, ZIP_SIGNATURE) > 0;
+}
+function findZipStart(data) {
+  const index = indexOf(data, ZIP_SIGNATURE);
+  if (index > 0) {
+    return data.subarray(index);
+  }
+  return data;
+}
+function getZipOffset(data) {
+  return indexOf(data, ZIP_SIGNATURE);
+}
+function isPathSafe(path) {
+  if (path.startsWith("/") || /^[a-zA-Z]:/.test(path)) {
+    return false;
+  }
+  if (path.includes("..")) {
+    return false;
+  }
+  if (path.includes("\\")) {
+    return false;
+  }
+  return true;
+}
+var ZipPreflightError = class extends Error {
+  constructor(message, totalSize, maxSize, oversizedEntry, entrySize, maxEntrySize) {
+    super(message);
+    this.totalSize = totalSize;
+    this.maxSize = maxSize;
+    this.oversizedEntry = oversizedEntry;
+    this.entrySize = entrySize;
+    this.maxEntrySize = maxEntrySize;
+    this.name = "ZipPreflightError";
+  }
+};
+function streamingUnzipSync(data, limits = DEFAULT_ZIP_LIMITS) {
+  const zipData = findZipStart(data);
+  const result = {};
+  let totalBytes = 0;
+  let fileCount = 0;
+  let error = null;
+  const unsafePathHandling = limits.unsafePathHandling ?? "skip";
+  const fileChunks = /* @__PURE__ */ new Map();
+  const unzipper = new Unzip((file) => {
+    if (error) return;
+    if (file.name.endsWith("/")) {
+      file.start();
+      return;
+    }
+    if (!isPathSafe(file.name)) {
+      const reason = file.name.includes("..") ? "path traversal (..)" : file.name.startsWith("/") || /^[a-zA-Z]:/.test(file.name) ? "absolute path" : "backslash in path";
+      if (unsafePathHandling === "reject") {
+        error = new ZipPreflightError(
+          `Unsafe path detected: "${file.name}" - ${reason}. This may be a path traversal attack.`
+        );
+        file.terminate();
+        return;
+      }
+      if (unsafePathHandling === "warn" && limits.onUnsafePath) {
+        limits.onUnsafePath(file.name, reason);
+      }
+      file.ondata = () => {
+      };
+      file.start();
+      return;
+    }
+    fileCount++;
+    if (fileCount > limits.maxFiles) {
+      error = new ZipPreflightError(
+        `File count ${fileCount} exceeds limit ${limits.maxFiles}`
+      );
+      file.terminate();
+      return;
+    }
+    const chunks = [];
+    fileChunks.set(file.name, chunks);
+    let fileBytes = 0;
+    file.ondata = (err, chunk, final) => {
+      if (error) return;
+      if (err) {
+        error = err;
+        return;
+      }
+      if (chunk && chunk.length > 0) {
+        fileBytes += chunk.length;
+        totalBytes += chunk.length;
+        if (fileBytes > limits.maxFileSize) {
+          error = new ZipPreflightError(
+            `File "${file.name}" actual size ${fileBytes} exceeds limit ${limits.maxFileSize}`,
+            void 0,
+            void 0,
+            file.name,
+            fileBytes,
+            limits.maxFileSize
+          );
+          file.terminate();
+          return;
+        }
+        if (totalBytes > limits.maxTotalSize) {
+          error = new ZipPreflightError(
+            `Total actual size ${totalBytes} exceeds limit ${limits.maxTotalSize}`,
+            totalBytes,
+            limits.maxTotalSize
+          );
+          file.terminate();
+          return;
+        }
+        chunks.push(chunk);
+      }
+      if (final && !error) {
+        result[file.name] = concat(...chunks);
+      }
+    };
+    file.start();
+  });
+  unzipper.register(UnzipInflate);
+  unzipper.register(UnzipPassThrough);
+  unzipper.push(zipData, true);
+  if (error) {
+    throw error;
+  }
+  return result;
+}
+
+// ../schemas/dist/index.js
+import { z } from "zod";
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+import "zod";
+var ISO8601Schema = z.string().datetime();
+var UUIDSchema = z.string().uuid();
+var SpecSchema = z.enum(["v2", "v3"]);
+var SourceFormatSchema = 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 = z.enum(["wrapped", "unwrapped", "legacy"]);
+var AssetTypeSchema = z.enum([
+  "icon",
+  "background",
+  "emotion",
+  "user_icon",
+  "sound",
+  "video",
+  "custom",
+  "x-risu-asset"
+]);
+var AssetDescriptorSchema = z.object({
+  type: AssetTypeSchema,
+  uri: z.string(),
+  name: z.string(),
+  ext: z.string()
+});
+var ExtractedAssetSchema = z.object({
+  descriptor: AssetDescriptorSchema,
+  data: z.instanceof(Uint8Array),
+  mimeType: z.string()
+});
+var CCv2LorebookEntrySchema = z2.object({
+  keys: z2.array(z2.string()),
+  content: z2.string(),
+  enabled: z2.boolean(),
+  insertion_order: z2.number().int(),
+  // Optional fields
+  extensions: z2.record(z2.unknown()).optional(),
+  case_sensitive: z2.boolean().optional(),
+  name: z2.string().optional(),
+  priority: z2.number().int().optional(),
+  id: z2.number().int().optional(),
+  comment: z2.string().optional(),
+  selective: z2.boolean().optional(),
+  secondary_keys: z2.array(z2.string()).optional(),
+  constant: z2.boolean().optional(),
+  position: z2.enum(["before_char", "after_char"]).optional()
+});
+var CCv2CharacterBookSchema = z2.object({
+  name: z2.string().optional(),
+  description: z2.string().optional(),
+  scan_depth: z2.number().int().nonnegative().optional(),
+  token_budget: z2.number().int().nonnegative().optional(),
+  recursive_scanning: z2.boolean().optional(),
+  extensions: z2.record(z2.unknown()).optional(),
+  entries: z2.array(CCv2LorebookEntrySchema)
+});
+var CCv2DataSchema = z2.object({
+  // Core fields - use .default('') to handle missing fields in malformed cards
+  name: z2.string().default(""),
+  description: z2.string().default(""),
+  personality: z2.string().nullable().default(""),
+  // Can be null in wild (141 cards)
+  scenario: z2.string().default(""),
+  first_mes: z2.string().default(""),
+  mes_example: z2.string().nullable().default(""),
+  // Can be null in wild (186 cards)
+  // Optional fields
+  creator_notes: z2.string().optional(),
+  system_prompt: z2.string().optional(),
+  post_history_instructions: z2.string().optional(),
+  alternate_greetings: z2.array(z2.string()).optional(),
+  character_book: CCv2CharacterBookSchema.optional().nullable(),
+  tags: z2.array(z2.string()).optional(),
+  creator: z2.string().optional(),
+  character_version: z2.string().optional(),
+  extensions: z2.record(z2.unknown()).optional()
+});
+var CCv2WrappedSchema = z2.object({
+  spec: z2.literal("chara_card_v2"),
+  spec_version: z2.literal("2.0"),
+  data: CCv2DataSchema
+});
+var CCv3LorebookEntrySchema = z3.object({
+  keys: z3.array(z3.string()),
+  content: z3.string(),
+  enabled: z3.boolean(),
+  insertion_order: z3.number().int(),
+  // Optional fields
+  case_sensitive: z3.boolean().optional(),
+  name: z3.string().optional(),
+  priority: z3.number().int().optional(),
+  id: z3.number().int().optional(),
+  comment: z3.string().optional(),
+  selective: z3.boolean().optional(),
+  secondary_keys: z3.array(z3.string()).optional(),
+  constant: z3.boolean().optional(),
+  position: z3.enum(["before_char", "after_char"]).optional(),
+  extensions: z3.record(z3.unknown()).optional(),
+  // v3 specific
+  automation_id: z3.string().optional(),
+  role: z3.enum(["system", "user", "assistant"]).optional(),
+  group: z3.string().optional(),
+  scan_frequency: z3.number().int().nonnegative().optional(),
+  probability: z3.number().min(0).max(1).optional(),
+  use_regex: z3.boolean().optional(),
+  depth: z3.number().int().nonnegative().optional(),
+  selective_logic: z3.enum(["AND", "NOT"]).optional()
+});
+var CCv3CharacterBookSchema = z3.object({
+  name: z3.string().optional(),
+  description: z3.string().optional(),
+  scan_depth: z3.number().int().nonnegative().optional(),
+  token_budget: z3.number().int().nonnegative().optional(),
+  recursive_scanning: z3.boolean().optional(),
+  extensions: z3.record(z3.unknown()).optional(),
+  entries: z3.array(CCv3LorebookEntrySchema)
+});
+var CCv3DataInnerSchema = z3.object({
+  // Core fields - use .default('') to handle missing fields in malformed cards
+  name: z3.string().default(""),
+  description: z3.string().default(""),
+  personality: z3.string().nullable().default(""),
+  // Can be null in wild (141 cards)
+  scenario: z3.string().default(""),
+  first_mes: z3.string().default(""),
+  mes_example: z3.string().nullable().default(""),
+  // Can be null in wild (186 cards)
+  // "Required" per spec but often missing in wild - use defaults for leniency
+  creator: z3.string().default(""),
+  character_version: z3.string().default(""),
+  tags: z3.array(z3.string()).default([]),
+  group_only_greetings: z3.array(z3.string()).default([]),
+  // Optional fields
+  creator_notes: z3.string().optional(),
+  system_prompt: z3.string().optional(),
+  post_history_instructions: z3.string().optional(),
+  alternate_greetings: z3.array(z3.string()).optional(),
+  character_book: CCv3CharacterBookSchema.optional().nullable(),
+  extensions: z3.record(z3.unknown()).optional(),
+  // v3 specific
+  assets: z3.array(AssetDescriptorSchema).optional(),
+  nickname: z3.string().optional(),
+  creator_notes_multilingual: z3.record(z3.string()).optional(),
+  source: z3.array(z3.string()).optional(),
+  creation_date: z3.number().int().nonnegative().optional(),
+  // Unix timestamp in seconds
+  modification_date: z3.number().int().nonnegative().optional()
+  // Unix timestamp in seconds
+});
+var CCv3DataSchema = z3.object({
+  spec: z3.literal("chara_card_v3"),
+  spec_version: z3.literal("3.0"),
+  data: CCv3DataInnerSchema
+});
+function hasRisuExtensions(extensions) {
+  if (!extensions) return false;
+  return "risuai" in extensions || "risu" in extensions;
+}
+
+// ../charx/dist/index.js
+import { zipSync } from "fflate";
+var DEFAULT_OPTIONS = {
+  maxFileSize: 10 * 1024 * 1024,
+  // 10MB
+  maxAssetSize: 50 * 1024 * 1024,
+  // 50MB (Risu standard)
+  maxTotalSize: 200 * 1024 * 1024,
+  // 200MB
+  preserveXMeta: true,
+  preserveModuleRisum: true
+};
+function isCharX(data) {
+  const zipOffset = getZipOffset(data);
+  if (zipOffset < 0) return false;
+  const zipData = data.subarray(zipOffset);
+  const cardJsonMarker = new TextEncoder().encode("card.json");
+  const scanSize = Math.min(zipData.length, 65536);
+  const startOffset = zipData.length - scanSize;
+  for (let i = startOffset; i < zipData.length - cardJsonMarker.length; i++) {
+    let found = true;
+    for (let j = 0; j < cardJsonMarker.length; j++) {
+      if (zipData[i + j] !== cardJsonMarker[j]) {
+        found = false;
+        break;
+      }
+    }
+    if (found) return true;
+  }
+  return false;
+}
+function readCharX(data, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let unzipped;
+  try {
+    unzipped = streamingUnzipSync(data, {
+      maxFileSize: opts.maxAssetSize,
+      maxTotalSize: opts.maxTotalSize,
+      maxFiles: 1e4
+      // CharX can have many assets
+    });
+  } catch (err) {
+    if (err instanceof ZipPreflightError) {
+      throw new SizeLimitError(
+        err.totalSize || err.entrySize || 0,
+        err.maxSize || err.maxEntrySize || opts.maxTotalSize,
+        err.oversizedEntry || "CharX archive"
+      );
+    }
+    throw new ParseError(
+      `Failed to unzip CharX: ${err instanceof Error ? err.message : String(err)}`,
+      "charx"
+    );
+  }
+  let cardJson = null;
+  const assets = [];
+  const metadata = /* @__PURE__ */ new Map();
+  let moduleRisum;
+  for (const [fileName, fileData] of Object.entries(unzipped)) {
+    if (fileName.endsWith("/") || fileData.length === 0) continue;
+    if (fileName === "card.json") {
+      if (fileData.length > opts.maxFileSize) {
+        throw new SizeLimitError(fileData.length, opts.maxFileSize, "card.json");
+      }
+      try {
+        const content = toString(fileData);
+        cardJson = JSON.parse(content);
+      } catch (err) {
+        throw new ParseError(
+          `Failed to parse card.json: ${err instanceof Error ? err.message : String(err)}`,
+          "charx"
+        );
+      }
+      continue;
+    }
+    if (opts.preserveXMeta) {
+      const metaMatch = fileName.match(/^x_meta\/(\d+)\.json$/);
+      if (metaMatch) {
+        const index = parseInt(metaMatch[1], 10);
+        try {
+          const content = toString(fileData);
+          const meta = JSON.parse(content);
+          metadata.set(index, meta);
+        } catch {
+        }
+        continue;
+      }
+    }
+    if (fileName === "module.risum" && opts.preserveModuleRisum) {
+      moduleRisum = fileData;
+      continue;
+    }
+    if (fileName.startsWith("assets/")) {
+      const name = fileName.split("/").pop() || "unknown";
+      const ext = name.split(".").pop() || "bin";
+      assets.push({
+        path: fileName,
+        descriptor: {
+          type: "custom",
+          name: name.replace(/\.[^.]+$/, ""),
+          // Remove extension
+          uri: `embeded://${fileName}`,
+          ext
+        },
+        buffer: fileData
+      });
+      continue;
+    }
+  }
+  if (!cardJson) {
+    throw new ParseError("CharX file does not contain card.json", "charx");
+  }
+  if (cardJson.spec !== "chara_card_v3") {
+    throw new ParseError(
+      `Invalid card spec: expected "chara_card_v3", got "${cardJson.spec}"`,
+      "charx"
+    );
+  }
+  const matchedAssets = matchAssetsToDescriptors(assets, cardJson.data.assets || []);
+  const isRisuFormat = !!moduleRisum || hasRisuExtensions(cardJson.data.extensions);
+  return {
+    card: cardJson,
+    assets: matchedAssets,
+    metadata: metadata.size > 0 ? metadata : void 0,
+    moduleRisum,
+    isRisuFormat
+  };
+}
+function matchAssetsToDescriptors(extractedAssets, descriptors) {
+  const assetsByPath = /* @__PURE__ */ new Map();
+  for (const asset of extractedAssets) {
+    assetsByPath.set(asset.path, asset);
+  }
+  const matched = [];
+  for (const descriptor of descriptors) {
+    const parsed = parseURI(descriptor.uri);
+    if (parsed.scheme === "embeded" && parsed.path) {
+      const asset = assetsByPath.get(parsed.path);
+      if (asset) {
+        matched.push({
+          ...asset,
+          descriptor
+        });
+      } else {
+        matched.push({
+          path: parsed.path,
+          descriptor,
+          buffer: void 0
+        });
+      }
+    } else if (parsed.scheme === "ccdefault") {
+      matched.push({
+        path: "ccdefault:",
+        descriptor,
+        buffer: void 0
+      });
+    } else if (parsed.scheme === "https" || parsed.scheme === "http") {
+      matched.push({
+        path: descriptor.uri,
+        descriptor,
+        buffer: void 0
+      });
+    } else if (parsed.scheme === "data") {
+      if (parsed.data && parsed.encoding === "base64") {
+        const buffer = decode(parsed.data);
+        matched.push({
+          path: "data:",
+          descriptor,
+          buffer
+        });
+      } else {
+        matched.push({
+          path: "data:",
+          descriptor,
+          buffer: void 0
+        });
+      }
+    }
+  }
+  return matched;
+}
+function readCardJsonOnly(data) {
+  let unzipped;
+  try {
+    unzipped = streamingUnzipSync(data, {
+      maxFileSize: DEFAULT_OPTIONS.maxFileSize,
+      // 10MB for card.json
+      maxTotalSize: DEFAULT_OPTIONS.maxTotalSize,
+      // 200MB total
+      maxFiles: 1e4
+    });
+  } catch (err) {
+    throw new ParseError(
+      `Failed to unzip CharX: ${err instanceof Error ? err.message : String(err)}`,
+      "charx"
+    );
+  }
+  const cardData = unzipped["card.json"];
+  if (!cardData) {
+    throw new ParseError("card.json not found in CharX file", "charx");
+  }
+  try {
+    const content = toString(cardData);
+    return JSON.parse(content);
+  } catch (err) {
+    throw new ParseError(
+      `Failed to parse card.json: ${err instanceof Error ? err.message : String(err)}`,
+      "charx"
+    );
+  }
+}
+async function readCharXAsync(data, options = {}) {
+  const result = readCharX(data, options);
+  if (!options.fetchRemoteAssets || !options.assetFetcher) {
+    return result;
+  }
+  const fetchedAssets = await Promise.all(
+    result.assets.map(async (asset) => {
+      if (asset.buffer) {
+        return asset;
+      }
+      const parsed = parseURI(asset.descriptor.uri);
+      if ((parsed.scheme === "https" || parsed.scheme === "http") && parsed.url) {
+        try {
+          const buffer = await options.assetFetcher(parsed.url);
+          if (buffer) {
+            return { ...asset, buffer };
+          }
+        } catch {
+        }
+      }
+      return asset;
+    })
+  );
+  return {
+    ...result,
+    assets: fetchedAssets
+  };
+}
+function getCharxCategory(mimetype) {
+  if (mimetype.startsWith("image/")) return "images";
+  if (mimetype.startsWith("audio/")) return "audio";
+  if (mimetype.startsWith("video/")) return "video";
+  return "other";
+}
+function sanitizeName(name, ext) {
+  let safeName = name;
+  if (safeName.toLowerCase().endsWith(`.${ext.toLowerCase()}`)) {
+    safeName = safeName.substring(0, safeName.length - (ext.length + 1));
+  }
+  safeName = safeName.replace(/[._]/g, "-").replace(/[^a-zA-Z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  if (!safeName) safeName = "asset";
+  return safeName;
+}
+function writeCharX(card, assets, options = {}) {
+  const {
+    spec = "v3",
+    compressionLevel = 6,
+    emitXMeta = spec === "risu",
+    emitReadme = false,
+    moduleRisum
+  } = options;
+  const transformedCard = transformAssetUris(card, assets);
+  const zipEntries = {};
+  const cardJson = JSON.stringify(transformedCard, null, 2);
+  zipEntries["card.json"] = [fromString(cardJson), { level: compressionLevel }];
+  if (emitReadme) {
+    const readme = `Character: ${card.data.name}
+Created with Character Foundry
+
+This is a CharX character card package.
+Import this file into SillyTavern, RisuAI, or other compatible applications.
+`;
+    zipEntries["readme.txt"] = [fromString(readme), { level: compressionLevel }];
+  }
+  let assetCount = 0;
+  for (let i = 0; i < assets.length; i++) {
+    const asset = assets[i];
+    const mimetype = getMimeTypeFromExt(asset.ext);
+    const category = getCharxCategory(mimetype);
+    const safeName = sanitizeName(asset.name, asset.ext);
+    const assetPath = `assets/${asset.type}/${category}/${safeName}.${asset.ext}`;
+    zipEntries[assetPath] = [asset.data, { level: compressionLevel }];
+    assetCount++;
+    if (emitXMeta && mimetype.startsWith("image/")) {
+      const metaJson = JSON.stringify({
+        type: mimetype.split("/")[1]?.toUpperCase() || "PNG"
+      });
+      zipEntries[`x_meta/${i}.json`] = [fromString(metaJson), { level: compressionLevel }];
+    }
+  }
+  if (moduleRisum) {
+    zipEntries["module.risum"] = [moduleRisum, { level: compressionLevel }];
+  }
+  const buffer = zipSync(zipEntries);
+  return {
+    buffer,
+    assetCount,
+    totalSize: buffer.length
+  };
+}
+function transformAssetUris(card, assets) {
+  const transformed = JSON.parse(JSON.stringify(card));
+  transformed.data.assets = assets.map((asset) => {
+    const mimetype = getMimeTypeFromExt(asset.ext);
+    const category = getCharxCategory(mimetype);
+    const safeName = sanitizeName(asset.name, asset.ext);
+    return {
+      type: asset.type,
+      uri: `embeded://assets/${asset.type}/${category}/${safeName}.${asset.ext}`,
+      name: safeName,
+      ext: asset.ext
+    };
+  });
+  return transformed;
+}
+async function writeCharXAsync(card, assets, options = {}) {
+  return writeCharX(card, assets, options);
+}
+export {
+  isCharX,
+  isJpegCharX,
+  readCardJsonOnly,
+  readCharX,
+  readCharXAsync,
+  writeCharX,
+  writeCharXAsync
+};
 //# sourceMappingURL=charx.js.map