@character-foundry/character-foundry 0.1.3 → 0.1.5

package/dist/lorebook.js

@@ -1,2 +1,842 @@
-export * from '@character-foundry/lorebook';
+// ../core/dist/index.js
+function toString(data) {
+  return new TextDecoder().decode(data);
+}
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+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";
+  }
+};
+
+// ../lorebook/dist/index.js
+function parseLorebook(data) {
+  let json;
+  try {
+    const text = toString(data);
+    json = JSON.parse(text);
+  } catch (err) {
+    throw new ParseError(
+      `Failed to parse lorebook JSON: ${err instanceof Error ? err.message : String(err)}`,
+      "lorebook"
+    );
+  }
+  const format = detectLorebookFormat(json);
+  const book = normalizeToCC3(json, format);
+  return {
+    book,
+    originalFormat: format,
+    originalShape: json
+  };
+}
+function detectLorebookFormat(data) {
+  if (!data || typeof data !== "object") {
+    return "unknown";
+  }
+  const obj = data;
+  if (Array.isArray(obj.entries)) {
+    const firstEntry = obj.entries[0];
+    if (firstEntry && Array.isArray(firstEntry.keys) && "content" in firstEntry) {
+      return "ccv3";
+    }
+  }
+  if (obj.entries && typeof obj.entries === "object" && !Array.isArray(obj.entries)) {
+    const entries = obj.entries;
+    const firstKey = Object.keys(entries)[0];
+    if (firstKey) {
+      const firstEntry = entries[firstKey];
+      if ("uid" in firstEntry && "key" in firstEntry && "content" in firstEntry) {
+        return "sillytavern";
+      }
+    }
+  }
+  if (obj.kind === "memory" && Array.isArray(obj.entries)) {
+    const firstEntry = obj.entries[0];
+    if (firstEntry && "keywords" in firstEntry && "entry" in firstEntry) {
+      return "agnai";
+    }
+  }
+  if (obj.type === "risu" || obj.ripiVersion !== void 0) {
+    return "risu";
+  }
+  if (obj.format === "wyvern" || obj.wyvern !== void 0) {
+    return "wyvern";
+  }
+  return "unknown";
+}
+function normalizeToCC3(data, format) {
+  switch (format) {
+    case "ccv3":
+      return normalizeCCv3(data);
+    case "sillytavern":
+      return normalizeSillyTavern(data);
+    case "agnai":
+      return normalizeAgnai(data);
+    case "risu":
+      return normalizeRisu(data);
+    case "wyvern":
+      return normalizeWyvern(data);
+    case "unknown":
+    default:
+      return attemptGenericNormalize(data);
+  }
+}
+function normalizeCCv3(data) {
+  const obj = data;
+  return {
+    name: typeof obj.name === "string" ? obj.name : void 0,
+    description: typeof obj.description === "string" ? obj.description : void 0,
+    entries: Array.isArray(obj.entries) ? obj.entries.map((e, i) => normalizeEntry(e, i)) : [],
+    extensions: typeof obj.extensions === "object" ? obj.extensions : void 0
+  };
+}
+function normalizeSillyTavern(data) {
+  const entries = [];
+  if (data.entries && typeof data.entries === "object") {
+    const entryList = Object.values(data.entries);
+    entryList.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    for (let i = 0; i < entryList.length; i++) {
+      const e = entryList[i];
+      entries.push({
+        keys: Array.isArray(e.key) ? e.key : [],
+        secondary_keys: Array.isArray(e.keysecondary) ? e.keysecondary : [],
+        content: e.content || "",
+        enabled: e.disable !== true,
+        insertion_order: e.order ?? i,
+        id: e.uid ?? i,
+        name: e.comment || `Entry ${e.uid ?? i}`,
+        comment: e.comment || "",
+        priority: e.order ?? 10,
+        selective: e.selective ?? false,
+        constant: e.constant ?? false,
+        position: mapSTPosition(e.position),
+        extensions: {
+          sillytavern: {
+            uid: e.uid,
+            selectiveLogic: e.selectiveLogic,
+            excludeRecursion: e.excludeRecursion,
+            probability: e.probability,
+            useProbability: e.useProbability,
+            depth: e.depth,
+            group: e.group,
+            scanDepth: e.scanDepth,
+            caseSensitive: e.caseSensitive,
+            matchWholeWords: e.matchWholeWords,
+            automationId: e.automationId,
+            role: e.role,
+            vectorized: e.vectorized,
+            groupOverride: e.groupOverride,
+            groupWeight: e.groupWeight,
+            sticky: e.sticky,
+            cooldown: e.cooldown,
+            delay: e.delay
+          }
+        }
+      });
+    }
+  }
+  return {
+    name: data.name,
+    description: data.description,
+    entries
+  };
+}
+function mapSTPosition(pos) {
+  switch (pos) {
+    case 0:
+      return "before_char";
+    case 1:
+      return "after_char";
+    case 2:
+      return "before_char";
+    // Top of AN
+    case 3:
+      return "after_char";
+    // Bottom of AN
+    case 4:
+      return "before_char";
+    // @ D
+    default:
+      return "before_char";
+  }
+}
+function normalizeAgnai(data) {
+  const entries = [];
+  if (Array.isArray(data.entries)) {
+    for (let i = 0; i < data.entries.length; i++) {
+      const e = data.entries[i];
+      entries.push({
+        keys: Array.isArray(e.keywords) ? e.keywords : [],
+        secondary_keys: [],
+        content: e.entry || "",
+        enabled: e.enabled !== false,
+        insertion_order: i,
+        id: i,
+        name: e.name || `Entry ${i}`,
+        comment: "",
+        priority: e.priority ?? 10,
+        selective: false,
+        constant: false,
+        position: "before_char",
+        extensions: {
+          agnai: {
+            weight: e.weight
+          }
+        }
+      });
+    }
+  }
+  return {
+    name: data.name,
+    description: data.description,
+    entries
+  };
+}
+function normalizeRisu(data) {
+  const obj = data;
+  return {
+    name: typeof obj.name === "string" ? obj.name : "Risu Lorebook",
+    entries: [],
+    extensions: { risu: obj }
+  };
+}
+function normalizeWyvern(data) {
+  const obj = data;
+  return {
+    name: typeof obj.name === "string" ? obj.name : "Wyvern Lorebook",
+    entries: [],
+    extensions: { wyvern: obj }
+  };
+}
+function attemptGenericNormalize(data) {
+  const obj = data;
+  const entries = [];
+  const possibleEntries = obj.entries || obj.items || obj.lore || obj.data;
+  if (Array.isArray(possibleEntries)) {
+    for (let i = 0; i < possibleEntries.length; i++) {
+      const e = possibleEntries[i];
+      entries.push(normalizeEntry(e, i));
+    }
+  }
+  return {
+    name: typeof obj.name === "string" ? obj.name : "Unknown Lorebook",
+    description: typeof obj.description === "string" ? obj.description : void 0,
+    entries,
+    extensions: { original: obj }
+  };
+}
+function normalizeEntry(entry, index) {
+  const e = entry;
+  let keys = [];
+  if (Array.isArray(e.keys)) keys = e.keys;
+  else if (Array.isArray(e.key)) keys = e.key;
+  else if (Array.isArray(e.keywords)) keys = e.keywords;
+  else if (typeof e.keys === "string") keys = [e.keys];
+  else if (typeof e.key === "string") keys = e.key.split(",").map((k) => k.trim());
+  let content = "";
+  if (typeof e.content === "string") content = e.content;
+  else if (typeof e.entry === "string") content = e.entry;
+  else if (typeof e.text === "string") content = e.text;
+  else if (typeof e.value === "string") content = e.value;
+  return {
+    keys,
+    secondary_keys: Array.isArray(e.secondary_keys) ? e.secondary_keys : [],
+    content,
+    enabled: e.enabled !== false && e.disable !== true,
+    insertion_order: typeof e.insertion_order === "number" ? e.insertion_order : index,
+    id: typeof e.id === "number" ? e.id : index,
+    name: typeof e.name === "string" ? e.name : `Entry ${index}`,
+    comment: typeof e.comment === "string" ? e.comment : "",
+    priority: typeof e.priority === "number" ? e.priority : 10,
+    selective: e.selective === true,
+    constant: e.constant === true,
+    position: "before_char"
+  };
+}
+function extractLorebookRefs(card) {
+  const refs = [];
+  const extensions = card.data.extensions;
+  if (!extensions) return refs;
+  if (extensions.chub && typeof extensions.chub === "object") {
+    const chub = extensions.chub;
+    if (Array.isArray(chub.linked_lorebooks)) {
+      for (const item of chub.linked_lorebooks) {
+        if (typeof item === "string") {
+          refs.push(parseLorebookUrl(item, "chub"));
+        } else if (typeof item === "object" && item !== null) {
+          const obj = item;
+          refs.push({
+            url: String(obj.url || obj.uri || ""),
+            platform: "chub",
+            id: obj.id ? String(obj.id) : void 0,
+            name: obj.name ? String(obj.name) : void 0
+          });
+        }
+      }
+    }
+  }
+  if (Array.isArray(extensions.world_infos)) {
+    for (const item of extensions.world_infos) {
+      if (typeof item === "string") {
+        refs.push(parseLorebookUrl(item, "unknown"));
+      } else if (typeof item === "object" && item !== null) {
+        const obj = item;
+        refs.push({
+          url: String(obj.url || obj.uri || ""),
+          platform: detectPlatformFromUrl(String(obj.url || obj.uri || "")),
+          id: obj.id ? String(obj.id) : void 0,
+          name: obj.name ? String(obj.name) : void 0
+        });
+      }
+    }
+  }
+  if (Array.isArray(extensions.linked_lorebooks)) {
+    for (const item of extensions.linked_lorebooks) {
+      if (typeof item === "string") {
+        refs.push(parseLorebookUrl(item, "unknown"));
+      } else if (typeof item === "object" && item !== null) {
+        const obj = item;
+        refs.push({
+          url: String(obj.url || obj.uri || ""),
+          platform: obj.platform ? String(obj.platform) : detectPlatformFromUrl(String(obj.url || "")),
+          id: obj.id ? String(obj.id) : void 0,
+          name: obj.name ? String(obj.name) : void 0
+        });
+      }
+    }
+  }
+  if (Array.isArray(extensions.ripiLinkedLorebooks)) {
+    for (const item of extensions.ripiLinkedLorebooks) {
+      if (typeof item === "object" && item !== null) {
+        const obj = item;
+        refs.push({
+          url: String(obj.url || ""),
+          platform: "risu",
+          id: obj.id ? String(obj.id) : void 0,
+          name: obj.name ? String(obj.name) : void 0
+        });
+      }
+    }
+  }
+  return refs.filter((r) => r.url.length > 0);
+}
+function parseLorebookUrl(url, defaultPlatform) {
+  const platform = detectPlatformFromUrl(url) || defaultPlatform;
+  const id = extractIdFromUrl(url, platform);
+  return { url, platform, id };
+}
+function detectPlatformFromUrl(url) {
+  if (url.includes("chub.ai") || url.includes("characterhub.org")) return "chub";
+  if (url.includes("risu.io") || url.includes("risuai")) return "risu";
+  if (url.includes("janitorai")) return "janitor";
+  if (url.includes("pygmalion")) return "pygmalion";
+  return "unknown";
+}
+function extractIdFromUrl(url, platform) {
+  try {
+    const parsed = new URL(url);
+    switch (platform) {
+      case "chub": {
+        const match = parsed.pathname.match(/\/lorebooks\/([^/]+\/[^/]+)/);
+        return match ? match[1] : void 0;
+      }
+      case "risu": {
+        const match = parsed.pathname.match(/\/lorebook\/([^/]+)/);
+        return match ? match[1] : void 0;
+      }
+      default:
+        return void 0;
+    }
+  } catch {
+    return void 0;
+  }
+}
+function extractLinkedEntries(book) {
+  const embeddedEntries = [];
+  const linkedBySource = /* @__PURE__ */ new Map();
+  for (const entry of book.entries || []) {
+    const source = getEntrySource(entry);
+    if (source) {
+      const existing = linkedBySource.get(source.linkedFrom) || [];
+      existing.push(entry);
+      linkedBySource.set(source.linkedFrom, existing);
+    } else {
+      embeddedEntries.push(entry);
+    }
+  }
+  const embedded = {
+    ...book,
+    entries: embeddedEntries
+  };
+  const linked = /* @__PURE__ */ new Map();
+  for (const [source, entries] of linkedBySource) {
+    const firstSource = getEntrySource(entries[0]);
+    linked.set(source, {
+      name: firstSource?.lorebookName || `Linked from ${source}`,
+      entries
+    });
+  }
+  return { embedded, linked };
+}
+function getEntrySource(entry) {
+  const ext = entry.extensions;
+  if (!ext?.lorebookSource) return void 0;
+  const source = ext.lorebookSource;
+  return {
+    linkedFrom: String(source.linkedFrom || ""),
+    platform: String(source.platform || "unknown"),
+    fetchedAt: String(source.fetchedAt || ""),
+    originalEntryId: source.originalEntryId ? String(source.originalEntryId) : void 0,
+    lorebookName: source.lorebookName ? String(source.lorebookName) : void 0
+  };
+}
+function getLorebookCollection(card) {
+  const embedded = [];
+  const linked = [];
+  if (card.data.character_book) {
+    const { embedded: embeddedBook, linked: linkedBooks } = extractLinkedEntries(
+      card.data.character_book
+    );
+    if (embeddedBook.entries.length > 0) {
+      embedded.push(embeddedBook);
+    }
+    for (const [source, book] of linkedBooks) {
+      const firstEntry = book.entries[0];
+      const sourceMeta = getEntrySource(firstEntry);
+      linked.push({
+        source,
+        platform: sourceMeta?.platform || "unknown",
+        fetchedAt: sourceMeta?.fetchedAt || "",
+        name: book.name,
+        book
+      });
+    }
+  }
+  const extensions = card.data.extensions;
+  if (extensions?.additional_lorebooks && Array.isArray(extensions.additional_lorebooks)) {
+    for (const additionalBook of extensions.additional_lorebooks) {
+      if (additionalBook && typeof additionalBook === "object") {
+        const book = additionalBook;
+        if (book.entries && book.entries.length > 0) {
+          embedded.push(book);
+        }
+      }
+    }
+  }
+  return { embedded, linked };
+}
+function stampEntriesWithSource(book, source) {
+  const stampedEntries = book.entries.map((entry) => stampEntry(entry, source));
+  return {
+    ...book,
+    entries: stampedEntries
+  };
+}
+function stampEntry(entry, source) {
+  const sourceMeta = {
+    ...source,
+    originalEntryId: entry.name || String(entry.id)
+  };
+  return {
+    ...entry,
+    extensions: {
+      ...entry.extensions,
+      lorebookSource: sourceMeta
+    }
+  };
+}
+function createLinkedLorebook(book, sourceUrl, platform, sourceId) {
+  const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const stampedBook = stampEntriesWithSource(book, {
+    linkedFrom: sourceUrl,
+    platform,
+    fetchedAt,
+    lorebookName: book.name
+  });
+  return {
+    source: sourceUrl,
+    platform,
+    sourceId,
+    fetchedAt,
+    name: book.name,
+    book: stampedBook
+  };
+}
+function addLinkedLorebookToCard(card, linkedBook) {
+  const extensions = card.data.extensions || {};
+  const additionalLorebooks = extensions.additional_lorebooks || [];
+  return {
+    ...card,
+    data: {
+      ...card.data,
+      extensions: {
+        ...extensions,
+        additional_lorebooks: [...additionalLorebooks, linkedBook.book]
+      }
+    }
+  };
+}
+function addEmbeddedLorebookToCard(card, book) {
+  if (!card.data.character_book || card.data.character_book.entries.length === 0) {
+    return {
+      ...card,
+      data: {
+        ...card.data,
+        character_book: book
+      }
+    };
+  }
+  const extensions = card.data.extensions || {};
+  const additionalLorebooks = extensions.additional_lorebooks || [];
+  return {
+    ...card,
+    data: {
+      ...card.data,
+      extensions: {
+        ...extensions,
+        additional_lorebooks: [...additionalLorebooks, book]
+      }
+    }
+  };
+}
+function removeLorebookFromCard(card, lorebookName) {
+  let updatedCard = { ...card, data: { ...card.data } };
+  if (card.data.character_book?.name === lorebookName) {
+    updatedCard.data.character_book = void 0;
+  }
+  const extensions = card.data.extensions || {};
+  if (Array.isArray(extensions.additional_lorebooks)) {
+    const filtered = extensions.additional_lorebooks.filter(
+      (book) => book.name !== lorebookName
+    );
+    updatedCard.data.extensions = {
+      ...extensions,
+      additional_lorebooks: filtered.length > 0 ? filtered : void 0
+    };
+  }
+  return updatedCard;
+}
+function removeLinkedEntriesBySource(card, sourceUrl) {
+  let updatedCard = { ...card, data: { ...card.data } };
+  if (card.data.character_book) {
+    updatedCard.data.character_book = removeSourceEntriesFromBook(
+      card.data.character_book,
+      sourceUrl
+    );
+  }
+  const extensions = card.data.extensions || {};
+  if (Array.isArray(extensions.additional_lorebooks)) {
+    const cleaned = extensions.additional_lorebooks.map((book) => removeSourceEntriesFromBook(book, sourceUrl)).filter((book) => book.entries.length > 0);
+    updatedCard.data.extensions = {
+      ...extensions,
+      additional_lorebooks: cleaned.length > 0 ? cleaned : void 0
+    };
+  }
+  return updatedCard;
+}
+function removeSourceEntriesFromBook(book, sourceUrl) {
+  const filteredEntries = book.entries.filter((entry) => {
+    const ext = entry.extensions;
+    if (!ext?.lorebookSource) return true;
+    const source = ext.lorebookSource;
+    return source.linkedFrom !== sourceUrl;
+  });
+  return {
+    ...book,
+    entries: filteredEntries
+  };
+}
+function replaceLorebookInCard(card, updatedBook) {
+  let updatedCard = { ...card, data: { ...card.data } };
+  if (card.data.character_book?.name === updatedBook.name) {
+    updatedCard.data.character_book = updatedBook;
+    return updatedCard;
+  }
+  const extensions = card.data.extensions || {};
+  if (Array.isArray(extensions.additional_lorebooks)) {
+    const updated = extensions.additional_lorebooks.map(
+      (book) => book.name === updatedBook.name ? updatedBook : book
+    );
+    updatedCard.data.extensions = {
+      ...extensions,
+      additional_lorebooks: updated
+    };
+  }
+  return updatedCard;
+}
+function setLorebookCollection(card, collection) {
+  const [mainBook, ...additionalEmbedded] = collection.embedded;
+  const linkedBooks = collection.linked.map((l) => l.book);
+  const additionalBooks = [...additionalEmbedded, ...linkedBooks];
+  const extensions = card.data.extensions || {};
+  return {
+    ...card,
+    data: {
+      ...card.data,
+      character_book: mainBook,
+      extensions: {
+        ...extensions,
+        additional_lorebooks: additionalBooks.length > 0 ? additionalBooks : void 0
+      }
+    }
+  };
+}
+function convertLorebook(book, targetFormat, originalShape) {
+  switch (targetFormat) {
+    case "ccv3":
+      return book;
+    case "sillytavern":
+      return toSillyTavern(book, originalShape);
+    case "agnai":
+      return toAgnai(book, originalShape);
+    case "risu":
+      return toRisu(book, originalShape);
+    case "wyvern":
+      return toWyvern(book, originalShape);
+    default:
+      return book;
+  }
+}
+function toSillyTavern(book, original) {
+  const entries = {};
+  for (let i = 0; i < book.entries.length; i++) {
+    const entry = book.entries[i];
+    const uid = entry.id ?? i;
+    const stExt = entry.extensions?.sillytavern || {};
+    entries[String(uid)] = {
+      uid,
+      key: entry.keys,
+      keysecondary: entry.secondary_keys,
+      comment: entry.comment || entry.name,
+      content: entry.content,
+      constant: entry.constant,
+      selective: entry.selective,
+      selectiveLogic: stExt.selectiveLogic,
+      order: entry.insertion_order,
+      position: mapCCv3Position(entry.position),
+      disable: !entry.enabled,
+      excludeRecursion: stExt.excludeRecursion,
+      probability: stExt.probability,
+      useProbability: stExt.useProbability,
+      depth: stExt.depth,
+      group: stExt.group,
+      scanDepth: stExt.scanDepth,
+      caseSensitive: stExt.caseSensitive,
+      matchWholeWords: stExt.matchWholeWords,
+      automationId: stExt.automationId,
+      role: stExt.role,
+      vectorized: stExt.vectorized,
+      groupOverride: stExt.groupOverride,
+      groupWeight: stExt.groupWeight,
+      sticky: stExt.sticky,
+      cooldown: stExt.cooldown,
+      delay: stExt.delay
+    };
+  }
+  return {
+    entries,
+    name: book.name,
+    description: book.description
+  };
+}
+function mapCCv3Position(position) {
+  switch (position) {
+    case "before_char":
+      return 0;
+    case "after_char":
+      return 1;
+    default:
+      return 0;
+  }
+}
+function toAgnai(book, original) {
+  const entries = book.entries.map((entry, i) => {
+    const agnaiExt = entry.extensions?.agnai || {};
+    return {
+      name: entry.name || `Entry ${i}`,
+      entry: entry.content,
+      keywords: entry.keys,
+      priority: entry.priority ?? 10,
+      weight: agnaiExt.weight ?? 1,
+      enabled: entry.enabled !== false
+    };
+  });
+  return {
+    kind: "memory",
+    name: book.name || "Lorebook",
+    description: book.description,
+    entries
+  };
+}
+function toRisu(book, original) {
+  if (original && typeof original === "object") {
+    const obj = original;
+    return {
+      ...obj,
+      // Update with CCv3 data
+      name: book.name,
+      entries: book.entries
+    };
+  }
+  return {
+    type: "risu",
+    name: book.name,
+    entries: book.entries
+  };
+}
+function toWyvern(book, original) {
+  if (original && typeof original === "object") {
+    const obj = original;
+    return {
+      ...obj,
+      // Update with CCv3 data
+      name: book.name,
+      entries: book.entries
+    };
+  }
+  return {
+    format: "wyvern",
+    name: book.name,
+    entries: book.entries
+  };
+}
+function serializeLorebook(book, format = "ccv3", originalShape, pretty = true) {
+  const converted = convertLorebook(book, format, originalShape);
+  return pretty ? JSON.stringify(converted, null, 2) : JSON.stringify(converted);
+}
+function serializeParsedLorebook(parsed, pretty = true) {
+  return serializeLorebook(
+    parsed.book,
+    parsed.originalFormat,
+    parsed.originalShape,
+    pretty
+  );
+}
+function mergeLorebooks(bookA, bookB, name) {
+  const maxIdA = Math.max(0, ...bookA.entries.map((e) => e.id ?? 0));
+  const renumberedB = bookB.entries.map((entry, i) => ({
+    ...entry,
+    id: maxIdA + 1 + i,
+    insertion_order: bookA.entries.length + i
+  }));
+  return {
+    name: name || bookA.name || bookB.name,
+    description: bookA.description || bookB.description,
+    entries: [...bookA.entries, ...renumberedB],
+    extensions: {
+      ...bookA.extensions,
+      ...bookB.extensions
+    }
+  };
+}
+function findEntriesByKeys(book, searchKeys, options = {}) {
+  const { caseSensitive = false, matchAll = false } = options;
+  const normalizeKey = (k) => caseSensitive ? k : k.toLowerCase();
+  const normalizedSearch = searchKeys.map(normalizeKey);
+  return book.entries.filter((entry) => {
+    const entryKeys = entry.keys.map(normalizeKey);
+    if (matchAll) {
+      return normalizedSearch.every((sk) => entryKeys.some((ek) => ek.includes(sk)));
+    } else {
+      return normalizedSearch.some((sk) => entryKeys.some((ek) => ek.includes(sk)));
+    }
+  });
+}
+function findEntryByNameOrId(book, nameOrId) {
+  if (typeof nameOrId === "number") {
+    return book.entries.find((e) => e.id === nameOrId);
+  }
+  return book.entries.find(
+    (e) => e.name === nameOrId || String(e.id) === nameOrId
+  );
+}
+function updateEntry(book, entryId, updates) {
+  const entries = book.entries.map((entry) => {
+    const matches = entry.id === entryId || entry.name === entryId || String(entry.id) === entryId;
+    if (matches) {
+      return { ...entry, ...updates };
+    }
+    return entry;
+  });
+  return { ...book, entries };
+}
+function addEntry(book, entry) {
+  const maxId = Math.max(0, ...book.entries.map((e) => e.id ?? 0));
+  const newEntry = {
+    ...entry,
+    id: maxId + 1,
+    insertion_order: book.entries.length
+  };
+  return {
+    ...book,
+    entries: [...book.entries, newEntry]
+  };
+}
+function removeEntry(book, entryId) {
+  const entries = book.entries.filter((entry) => {
+    const matches = entry.id === entryId || entry.name === entryId || String(entry.id) === entryId;
+    return !matches;
+  });
+  return { ...book, entries };
+}
+function reorderEntries(book, entryIds) {
+  const entryMap = new Map(
+    book.entries.map((e) => [e.id ?? e.name, e])
+  );
+  const reordered = [];
+  for (let i = 0; i < entryIds.length; i++) {
+    const id = entryIds[i];
+    const entry = entryMap.get(id) || book.entries.find((e) => e.name === id);
+    if (entry) {
+      reordered.push({ ...entry, insertion_order: i });
+      entryMap.delete(entry.id ?? entry.name);
+    }
+  }
+  for (const entry of entryMap.values()) {
+    reordered.push({ ...entry, insertion_order: reordered.length });
+  }
+  return { ...book, entries: reordered };
+}
+export {
+  addEmbeddedLorebookToCard,
+  addEntry,
+  addLinkedLorebookToCard,
+  convertLorebook,
+  createLinkedLorebook,
+  detectLorebookFormat,
+  extractLinkedEntries,
+  extractLorebookRefs,
+  findEntriesByKeys,
+  findEntryByNameOrId,
+  getLorebookCollection,
+  mergeLorebooks,
+  normalizeToCC3,
+  parseLorebook,
+  removeEntry,
+  removeLinkedEntriesBySource,
+  removeLorebookFromCard,
+  reorderEntries,
+  replaceLorebookInCard,
+  serializeLorebook,
+  serializeParsedLorebook,
+  setLorebookCollection,
+  stampEntriesWithSource,
+  updateEntry
+};
 //# sourceMappingURL=lorebook.js.map