@ashdev/codex-plugin-metadata-openlibrary 1.37.0 → 1.38.0

package/dist/index.js

@@ -9,606 +9,407 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/api.ts
-var api_exports = {};
-__export(api_exports, {
-  buildOpenLibraryUrl: () => buildOpenLibraryUrl,
-  clearCache: () => clearCache,
-  extractOlid: () => extractOlid,
-  getAuthor: () => getAuthor,
-  getCoverUrlById: () => getCoverUrlById,
-  getCoverUrlByIsbn: () => getCoverUrlByIsbn,
-  getCoverUrlByOlid: () => getCoverUrlByOlid,
-  getEditionByIsbn: () => getEditionByIsbn,
-  getWork: () => getWork,
-  getWorkEditions: () => getWorkEditions,
-  isValidIsbn: () => isValidIsbn,
-  normalizeIsbn: () => normalizeIsbn,
-  parseDescription: () => parseDescription,
-  parseLanguage: () => parseLanguage,
-  parseYear: () => parseYear,
-  searchBooks: () => searchBooks
-});
-function getCached(key) {
-  const entry = cache.get(key);
-  if (entry && Date.now() - entry.timestamp < CACHE_TTL_MS) {
-    return entry.data;
-  }
-  if (entry) {
-    cache.delete(key);
-  }
-  return null;
-}
-function setCache(key, data) {
-  cache.set(key, { data, timestamp: Date.now() });
-}
-async function fetchJson(url, description) {
-  const cached = getCached(url);
-  if (cached !== null) {
-    return cached;
-  }
-  try {
-    const response = await fetch(url, {
-      headers: {
-        "User-Agent": "Codex/1.0 (https://github.com/AshDevFr/codex; codex-plugin)",
-        Accept: "application/json"
-      }
-    });
-    if (!response.ok) {
-      if (response.status === 404) {
-        return null;
-      }
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    const data = await response.json();
-    setCache(url, data);
-    return data;
-  } catch (error) {
-    console.error(`[openlibrary] Failed to fetch ${description}:`, error);
-    return null;
-  }
-}
-function normalizeIsbn(isbn) {
-  return isbn.replace(/[-\s]/g, "").toUpperCase();
-}
-function isValidIsbn(isbn) {
-  const normalized = normalizeIsbn(isbn);
-  return normalized.length === 10 || normalized.length === 13;
-}
-async function getEditionByIsbn(isbn) {
-  const normalized = normalizeIsbn(isbn);
-  const url = `${BASE_URL}/isbn/${normalized}.json`;
-  return fetchJson(url, `edition by ISBN ${normalized}`);
-}
-async function getWork(workKey) {
-  const key = workKey.startsWith("/works/") ? workKey : `/works/${workKey}`;
-  const url = `${BASE_URL}${key}.json`;
-  return fetchJson(url, `work ${key}`);
-}
-async function getWorkEditions(workKey, limit = 5) {
-  const key = workKey.startsWith("/works/") ? workKey : `/works/${workKey}`;
-  const url = `${BASE_URL}${key}/editions.json?limit=${limit}`;
-  const response = await fetchJson(url, `editions for ${key}`);
-  return response?.entries || [];
-}
-async function getAuthor(authorKey) {
-  const key = authorKey.startsWith("/authors/") ? authorKey : `/authors/${authorKey}`;
-  const url = `${BASE_URL}${key}.json`;
-  return fetchJson(url, `author ${key}`);
-}
-async function searchBooks(query, options = {}) {
-  const { author, limit = 10 } = options;
-  if (author) {
-    const params2 = new URLSearchParams({
-      title: query,
-      author,
-      fields: SEARCH_FIELDS,
-      limit: String(limit)
-    });
-    const url2 = `${BASE_URL}/search.json?${params2}`;
-    const response = await fetchJson(
-      url2,
-      `search title="${query}" author="${author}"`
-    );
-    if (response?.docs?.length) {
-      return response;
-    }
-  }
-  const params = new URLSearchParams({
-    q: query,
-    fields: SEARCH_FIELDS,
-    limit: String(limit)
-  });
-  if (author) {
-    params.set("author", author);
-  }
-  const url = `${BASE_URL}/search.json?${params}`;
-  return fetchJson(url, `search "${query}"`);
-}
-function getCoverUrlByIsbn(isbn, size) {
-  const normalized = normalizeIsbn(isbn);
-  return `${COVERS_BASE_URL}/b/isbn/${normalized}-${size}.jpg`;
-}
-function getCoverUrlById(coverId, size) {
-  return `${COVERS_BASE_URL}/b/id/${coverId}-${size}.jpg`;
-}
-function getCoverUrlByOlid(olid, size) {
-  const id = olid.replace(/^\/(?:books|works)\//, "");
-  return `${COVERS_BASE_URL}/b/olid/${id}-${size}.jpg`;
-}
-function parseYear(dateStr) {
-  if (!dateStr) return void 0;
-  const match = dateStr.match(/(?:^|[^0-9])(1[89]\d{2}|20\d{2})(?:[^0-9]|$)/);
-  if (match) {
-    return Number.parseInt(match[1], 10);
-  }
-  return void 0;
-}
-function parseDescription(desc) {
-  if (!desc) return void 0;
-  const raw = typeof desc === "string" ? desc : desc.value;
-  return stripHtml(raw);
-}
-function stripHtml(html) {
-  let text = html;
-  text = text.replace(/<\/(p|div|li|tr|h[1-6])>/gi, "\n");
-  text = text.replace(/<br\s*\/?>/gi, "\n");
-  text = text.replace(/<[^>]+>/g, "");
-  text = text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&apos;/g, "'").replace(/&nbsp;/g, " ");
-  text = text.replace(/[^\S\n]+/g, " ");
-  text = text.replace(/\n{3,}/g, "\n\n");
-  text = text.split("\n").map((line) => line.trim()).join("\n").trim();
-  return text || void 0;
-}
-function parseLanguage(langRef) {
-  if (!langRef) return void 0;
-  const match = langRef.match(/\/languages\/(\w+)$/);
-  if (!match) return void 0;
-  const code = match[1].toLowerCase();
-  const languageMap = {
-    eng: "en",
-    spa: "es",
-    fre: "fr",
-    fra: "fr",
-    ger: "de",
-    deu: "de",
-    ita: "it",
-    por: "pt",
-    rus: "ru",
-    jpn: "ja",
-    chi: "zh",
-    zho: "zh",
-    kor: "ko",
-    ara: "ar",
-    hin: "hi",
-    pol: "pl",
-    tur: "tr",
-    dut: "nl",
-    nld: "nl",
-    swe: "sv",
-    nor: "no",
-    dan: "da",
-    fin: "fi",
-    cze: "cs",
-    ces: "cs",
-    gre: "el",
-    ell: "el",
-    heb: "he",
-    hun: "hu",
-    rom: "ro",
-    ron: "ro",
-    tha: "th",
-    vie: "vi",
-    ind: "id",
-    mal: "ms",
-    msa: "ms",
-    ukr: "uk",
-    cat: "ca",
-    lat: "la"
-  };
-  return languageMap[code] || code;
-}
-function extractOlid(key) {
-  return key.replace(/^\/(?:works|books|authors)\//, "");
-}
-function buildOpenLibraryUrl(key) {
-  return `${BASE_URL}${key.startsWith("/") ? key : `/${key}`}`;
-}
-function clearCache() {
-  cache.clear();
-}
-var BASE_URL, COVERS_BASE_URL, CACHE_TTL_MS, cache, SEARCH_FIELDS;
-var init_api = __esm({
-  "src/api.ts"() {
-    "use strict";
-    BASE_URL = "https://openlibrary.org";
-    COVERS_BASE_URL = "https://covers.openlibrary.org";
-    CACHE_TTL_MS = 15 * 60 * 1e3;
-    cache = /* @__PURE__ */ new Map();
-    SEARCH_FIELDS = [
-      "key",
-      "title",
-      "subtitle",
-      "author_name",
-      "author_key",
-      "first_publish_year",
-      "publish_year",
-      "publisher",
-      "isbn",
-      "number_of_pages_median",
-      "cover_i",
-      "cover_edition_key",
-      "edition_count",
-      "language",
-      "subject",
-      "ratings_average",
-      "ratings_count"
-    ].join(",");
+// node_modules/@ashdev/codex-plugin-sdk/dist/types/rpc.js
+var JSON_RPC_ERROR_CODES;
+var init_rpc = __esm({
+  "node_modules/@ashdev/codex-plugin-sdk/dist/types/rpc.js"() {
+    JSON_RPC_ERROR_CODES = {
+      /** Invalid JSON was received */
+      PARSE_ERROR: -32700,
+      /** The JSON sent is not a valid Request object */
+      INVALID_REQUEST: -32600,
+      /** The method does not exist / is not available */
+      METHOD_NOT_FOUND: -32601,
+      /** Invalid method parameter(s) */
+      INVALID_PARAMS: -32602,
+      /** Internal JSON-RPC error */
+      INTERNAL_ERROR: -32603
+    };
   }
 });
 
-// node_modules/@ashdev/codex-plugin-sdk/dist/types/rpc.js
-var JSON_RPC_ERROR_CODES = {
-  /** Invalid JSON was received */
-  PARSE_ERROR: -32700,
-  /** The JSON sent is not a valid Request object */
-  INVALID_REQUEST: -32600,
-  /** The method does not exist / is not available */
-  METHOD_NOT_FOUND: -32601,
-  /** Invalid method parameter(s) */
-  INVALID_PARAMS: -32602,
-  /** Internal JSON-RPC error */
-  INTERNAL_ERROR: -32603
-};
-
 // node_modules/@ashdev/codex-plugin-sdk/dist/errors.js
-var PluginError = class extends Error {
-  data;
-  constructor(message, data) {
-    super(message);
-    this.name = this.constructor.name;
-    this.data = data;
-  }
-  /**
-   * Convert to JSON-RPC error format
-   */
-  toJsonRpcError() {
-    return {
-      code: this.code,
-      message: this.message,
-      data: this.data
+var PluginError;
+var init_errors = __esm({
+  "node_modules/@ashdev/codex-plugin-sdk/dist/errors.js"() {
+    init_rpc();
+    PluginError = class extends Error {
+      data;
+      constructor(message, data) {
+        super(message);
+        this.name = this.constructor.name;
+        this.data = data;
+      }
+      /**
+       * Convert to JSON-RPC error format
+       */
+      toJsonRpcError() {
+        return {
+          code: this.code,
+          message: this.message,
+          data: this.data
+        };
+      }
     };
   }
-};
+});
 
 // node_modules/@ashdev/codex-plugin-sdk/dist/request-context.js
 import { AsyncLocalStorage } from "node:async_hooks";
-var store = new AsyncLocalStorage();
 function runWithParentRequestId(forwardRequestId, fn) {
   return store.run(forwardRequestId, fn);
 }
 function currentParentRequestId() {
   return store.getStore();
-}
-
-// node_modules/@ashdev/codex-plugin-sdk/dist/host-rpc.js
-var HostRpcError = class extends Error {
-  code;
-  data;
-  constructor(message, code, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-    this.name = "HostRpcError";
-  }
-};
-var HostRpcClient = class {
-  // Start the counter high so it can't collide with PluginStorage's id space.
-  // `Number.MAX_SAFE_INTEGER` is far above this, so we have plenty of room
-  // before wrapping (and we never expect a single plugin lifetime to issue
-  // more than ~9 quintillion calls).
-  nextId = 1e9;
-  pendingRequests = /* @__PURE__ */ new Map();
-  writeFn;
-  /**
-   * @param writeFn - Optional custom write function (defaults to
-   *   `process.stdout.write`). Useful for testing.
-   */
-  constructor(writeFn) {
-    this.writeFn = writeFn ?? ((line) => {
-      process.stdout.write(line);
-    });
-  }
-  /**
-   * Send a JSON-RPC request to the host and resolve with the result.
-   *
-   * @param method - JSON-RPC method name (e.g. `"releases/list_tracked"`).
-   * @param params - Method-specific params. Pass `undefined` when the method
-   *   takes no params.
-   */
-  async call(method, params) {
-    const id = this.nextId++;
-    const parent = currentParentRequestId();
-    const request = {
-      jsonrpc: "2.0",
-      id,
-      method,
-      params,
-      ...parent !== void 0 ? { parentRequestId: parent } : {}
-    };
-    return new Promise((resolve, reject) => {
-      this.pendingRequests.set(id, {
-        resolve: (v) => resolve(v),
-        reject
-      });
-      try {
-        this.writeFn(`${JSON.stringify(request)}
-`);
-      } catch (err) {
-        this.pendingRequests.delete(id);
-        const message = err instanceof Error ? err.message : "Unknown write error";
-        reject(new HostRpcError(`Failed to send request: ${message}`, -1));
-      }
-    });
-  }
-  /**
-   * Process an incoming JSON-RPC response line. Returns `true` if this
-   * client owned the response id and resolved it, `false` otherwise (so
-   * other clients can try).
-   *
-   * Called by the plugin server's main loop on every response.
-   */
-  handleResponse(line) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      return false;
-    let parsed;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      return false;
-    }
-    const obj = parsed;
-    if (obj.method !== void 0)
-      return false;
-    const rawId = obj.id;
-    if (typeof rawId !== "number")
-      return false;
-    if (!this.pendingRequests.has(rawId))
-      return false;
-    const pending = this.pendingRequests.get(rawId);
-    if (!pending)
-      return false;
-    this.pendingRequests.delete(rawId);
-    if ("error" in obj && obj.error) {
-      const err = obj.error;
-      pending.reject(new HostRpcError(err.message, err.code, err.data));
-    } else {
-      pending.resolve(obj.result);
-    }
-    return true;
-  }
-  /** Reject all pending requests (e.g. on shutdown). */
-  cancelAll() {
-    for (const [, pending] of this.pendingRequests) {
-      pending.reject(new HostRpcError("Host RPC client stopped", -1));
-    }
-    this.pendingRequests.clear();
-  }
-};
-
-// node_modules/@ashdev/codex-plugin-sdk/dist/logger.js
-var LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-var Logger = class {
-  name;
-  minLevel;
-  timestamps;
-  constructor(options) {
-    this.name = options.name;
-    this.minLevel = LOG_LEVELS[options.level ?? "info"];
-    this.timestamps = options.timestamps ?? true;
-  }
-  shouldLog(level) {
-    return LOG_LEVELS[level] >= this.minLevel;
-  }
-  format(level, message, data) {
-    const parts = [];
-    if (this.timestamps) {
-      parts.push((/* @__PURE__ */ new Date()).toISOString());
-    }
-    parts.push(`[${level.toUpperCase()}]`);
-    parts.push(`[${this.name}]`);
-    parts.push(message);
-    if (data !== void 0) {
-      if (data instanceof Error) {
-        parts.push(`- ${data.message}`);
-        if (data.stack) {
-          parts.push(`
-${data.stack}`);
-        }
-      } else if (typeof data === "object") {
-        parts.push(`- ${JSON.stringify(data)}`);
-      } else {
-        parts.push(`- ${String(data)}`);
-      }
-    }
-    return parts.join(" ");
-  }
-  log(level, message, data) {
-    if (this.shouldLog(level)) {
-      process.stderr.write(`${this.format(level, message, data)}
-`);
-    }
-  }
-  debug(message, data) {
-    this.log("debug", message, data);
-  }
-  info(message, data) {
-    this.log("info", message, data);
-  }
-  warn(message, data) {
-    this.log("warn", message, data);
-  }
-  error(message, data) {
-    this.log("error", message, data);
-  }
-};
-function createLogger(options) {
-  return new Logger(options);
-}
-
-// node_modules/@ashdev/codex-plugin-sdk/dist/server.js
-import { createInterface } from "node:readline";
-
-// node_modules/@ashdev/codex-plugin-sdk/dist/storage.js
-var StorageError = class extends Error {
-  code;
-  data;
-  constructor(message, code, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-    this.name = "StorageError";
-  }
-};
-var PluginStorage = class {
-  nextId = 1;
-  pendingRequests = /* @__PURE__ */ new Map();
-  writeFn;
-  /**
-   * Create a new storage client.
-   *
-   * @param writeFn - Optional custom write function (defaults to process.stdout.write).
-   *                  Useful for testing or custom transport layers.
-   */
-  constructor(writeFn) {
-    this.writeFn = writeFn ?? ((line) => {
-      process.stdout.write(line);
-    });
-  }
-  /**
-   * Get a value by key
-   *
-   * @param key - Storage key to retrieve
-   * @returns The stored data and optional expiration, or null data if key doesn't exist
-   */
-  async get(key) {
-    return await this.sendRequest("storage/get", { key });
-  }
-  /**
-   * Set a value by key (upsert - creates or updates)
-   *
-   * @param key - Storage key
-   * @param data - JSON-serializable data to store
-   * @param expiresAt - Optional expiration timestamp (ISO 8601)
-   * @returns Success indicator
-   */
-  async set(key, data, expiresAt) {
-    const params = { key, data };
-    if (expiresAt !== void 0) {
-      params.expiresAt = expiresAt;
-    }
-    return await this.sendRequest("storage/set", params);
-  }
-  /**
-   * Delete a value by key
-   *
-   * @param key - Storage key to delete
-   * @returns Whether the key existed and was deleted
-   */
-  async delete(key) {
-    return await this.sendRequest("storage/delete", { key });
-  }
-  /**
-   * List all keys for this plugin instance (excluding expired)
-   *
-   * @returns List of key entries with metadata
-   */
-  async list() {
-    return await this.sendRequest("storage/list", {});
-  }
-  /**
-   * Clear all data for this plugin instance
-   *
-   * @returns Number of entries deleted
-   */
-  async clear() {
-    return await this.sendRequest("storage/clear", {});
-  }
-  /**
-   * Handle an incoming JSON-RPC response line from the host.
-   *
-   * Call this method from your readline handler to deliver responses
-   * back to pending storage requests.
-   */
-  handleResponse(line) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      return;
-    let parsed;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      return;
-    }
-    const obj = parsed;
-    if (obj.method !== void 0) {
-      return;
-    }
-    const id = obj.id;
-    if (id === void 0 || id === null)
-      return;
-    const pending = this.pendingRequests.get(id);
-    if (!pending)
-      return;
-    this.pendingRequests.delete(id);
-    if ("error" in obj && obj.error) {
-      const err = obj.error;
-      pending.reject(new StorageError(err.message, err.code, err.data));
-    } else {
-      pending.resolve(obj.result);
-    }
+}
+var store;
+var init_request_context = __esm({
+  "node_modules/@ashdev/codex-plugin-sdk/dist/request-context.js"() {
+    store = new AsyncLocalStorage();
   }
-  /**
-   * Cancel all pending requests (e.g. on shutdown).
-   */
-  cancelAll() {
-    for (const [, pending] of this.pendingRequests) {
-      pending.reject(new StorageError("Storage client stopped", -1));
-    }
-    this.pendingRequests.clear();
+});
+
+// node_modules/@ashdev/codex-plugin-sdk/dist/host-rpc.js
+var HostRpcError, HostRpcClient;
+var init_host_rpc = __esm({
+  "node_modules/@ashdev/codex-plugin-sdk/dist/host-rpc.js"() {
+    init_request_context();
+    HostRpcError = class extends Error {
+      code;
+      data;
+      constructor(message, code, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "HostRpcError";
+      }
+    };
+    HostRpcClient = class {
+      // Start the counter high so it can't collide with PluginStorage's id space.
+      // `Number.MAX_SAFE_INTEGER` is far above this, so we have plenty of room
+      // before wrapping (and we never expect a single plugin lifetime to issue
+      // more than ~9 quintillion calls).
+      nextId = 1e9;
+      pendingRequests = /* @__PURE__ */ new Map();
+      writeFn;
+      /**
+       * @param writeFn - Optional custom write function (defaults to
+       *   `process.stdout.write`). Useful for testing.
+       */
+      constructor(writeFn) {
+        this.writeFn = writeFn ?? ((line) => {
+          process.stdout.write(line);
+        });
+      }
+      /**
+       * Send a JSON-RPC request to the host and resolve with the result.
+       *
+       * @param method - JSON-RPC method name (e.g. `"releases/list_tracked"`).
+       * @param params - Method-specific params. Pass `undefined` when the method
+       *   takes no params.
+       */
+      async call(method, params) {
+        const id = this.nextId++;
+        const parent = currentParentRequestId();
+        const request = {
+          jsonrpc: "2.0",
+          id,
+          method,
+          params,
+          ...parent !== void 0 ? { parentRequestId: parent } : {}
+        };
+        return new Promise((resolve, reject) => {
+          this.pendingRequests.set(id, {
+            resolve: (v) => resolve(v),
+            reject
+          });
+          try {
+            this.writeFn(`${JSON.stringify(request)}
+`);
+          } catch (err) {
+            this.pendingRequests.delete(id);
+            const message = err instanceof Error ? err.message : "Unknown write error";
+            reject(new HostRpcError(`Failed to send request: ${message}`, -1));
+          }
+        });
+      }
+      /**
+       * Process an incoming JSON-RPC response line. Returns `true` if this
+       * client owned the response id and resolved it, `false` otherwise (so
+       * other clients can try).
+       *
+       * Called by the plugin server's main loop on every response.
+       */
+      handleResponse(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+          return false;
+        let parsed;
+        try {
+          parsed = JSON.parse(trimmed);
+        } catch {
+          return false;
+        }
+        const obj = parsed;
+        if (obj.method !== void 0)
+          return false;
+        const rawId = obj.id;
+        if (typeof rawId !== "number")
+          return false;
+        if (!this.pendingRequests.has(rawId))
+          return false;
+        const pending = this.pendingRequests.get(rawId);
+        if (!pending)
+          return false;
+        this.pendingRequests.delete(rawId);
+        if ("error" in obj && obj.error) {
+          const err = obj.error;
+          pending.reject(new HostRpcError(err.message, err.code, err.data));
+        } else {
+          pending.resolve(obj.result);
+        }
+        return true;
+      }
+      /** Reject all pending requests (e.g. on shutdown). */
+      cancelAll() {
+        for (const [, pending] of this.pendingRequests) {
+          pending.reject(new HostRpcError("Host RPC client stopped", -1));
+        }
+        this.pendingRequests.clear();
+      }
+    };
   }
-  // ===========================================================================
-  // Internal
-  // ===========================================================================
-  sendRequest(method, params) {
-    const id = this.nextId++;
-    const request = {
-      jsonrpc: "2.0",
-      id,
-      method,
-      params
+});
+
+// node_modules/@ashdev/codex-plugin-sdk/dist/logger.js
+function createLogger(options) {
+  return new Logger(options);
+}
+var LOG_LEVELS, Logger;
+var init_logger = __esm({
+  "node_modules/@ashdev/codex-plugin-sdk/dist/logger.js"() {
+    LOG_LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
     };
-    return new Promise((resolve, reject) => {
-      this.pendingRequests.set(id, { resolve, reject });
-      try {
-        this.writeFn(`${JSON.stringify(request)}
+    Logger = class {
+      name;
+      minLevel;
+      timestamps;
+      constructor(options) {
+        this.name = options.name;
+        this.minLevel = LOG_LEVELS[options.level ?? "info"];
+        this.timestamps = options.timestamps ?? true;
+      }
+      /**
+       * Change the minimum level at runtime. Plugins typically call this from
+       * `onInitialize` with the host-supplied `logLevel` so debug output can be
+       * toggled centrally via the `plugins.log_level` Codex config without a
+       * rebuild.
+       */
+      setLevel(level) {
+        this.minLevel = LOG_LEVELS[level];
+      }
+      shouldLog(level) {
+        return LOG_LEVELS[level] >= this.minLevel;
+      }
+      format(level, message, data) {
+        const parts = [];
+        if (this.timestamps) {
+          parts.push((/* @__PURE__ */ new Date()).toISOString());
+        }
+        parts.push(`[${level.toUpperCase()}]`);
+        parts.push(`[${this.name}]`);
+        parts.push(message);
+        if (data !== void 0) {
+          if (data instanceof Error) {
+            parts.push(`- ${data.message}`);
+            if (data.stack) {
+              parts.push(`
+${data.stack}`);
+            }
+          } else if (typeof data === "object") {
+            parts.push(`- ${JSON.stringify(data)}`);
+          } else {
+            parts.push(`- ${String(data)}`);
+          }
+        }
+        return parts.join(" ");
+      }
+      log(level, message, data) {
+        if (this.shouldLog(level)) {
+          process.stderr.write(`${this.format(level, message, data)}
 `);
-      } catch (err) {
+        }
+      }
+      debug(message, data) {
+        this.log("debug", message, data);
+      }
+      info(message, data) {
+        this.log("info", message, data);
+      }
+      warn(message, data) {
+        this.log("warn", message, data);
+      }
+      error(message, data) {
+        this.log("error", message, data);
+      }
+    };
+  }
+});
+
+// node_modules/@ashdev/codex-plugin-sdk/dist/storage.js
+var StorageError, PluginStorage;
+var init_storage = __esm({
+  "node_modules/@ashdev/codex-plugin-sdk/dist/storage.js"() {
+    StorageError = class extends Error {
+      code;
+      data;
+      constructor(message, code, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "StorageError";
+      }
+    };
+    PluginStorage = class {
+      nextId = 1;
+      pendingRequests = /* @__PURE__ */ new Map();
+      writeFn;
+      /**
+       * Create a new storage client.
+       *
+       * @param writeFn - Optional custom write function (defaults to process.stdout.write).
+       *                  Useful for testing or custom transport layers.
+       */
+      constructor(writeFn) {
+        this.writeFn = writeFn ?? ((line) => {
+          process.stdout.write(line);
+        });
+      }
+      /**
+       * Get a value by key
+       *
+       * @param key - Storage key to retrieve
+       * @returns The stored data and optional expiration, or null data if key doesn't exist
+       */
+      async get(key) {
+        return await this.sendRequest("storage/get", { key });
+      }
+      /**
+       * Set a value by key (upsert - creates or updates)
+       *
+       * @param key - Storage key
+       * @param data - JSON-serializable data to store
+       * @param expiresAt - Optional expiration timestamp (ISO 8601)
+       * @returns Success indicator
+       */
+      async set(key, data, expiresAt) {
+        const params = { key, data };
+        if (expiresAt !== void 0) {
+          params.expiresAt = expiresAt;
+        }
+        return await this.sendRequest("storage/set", params);
+      }
+      /**
+       * Delete a value by key
+       *
+       * @param key - Storage key to delete
+       * @returns Whether the key existed and was deleted
+       */
+      async delete(key) {
+        return await this.sendRequest("storage/delete", { key });
+      }
+      /**
+       * List all keys for this plugin instance (excluding expired)
+       *
+       * @returns List of key entries with metadata
+       */
+      async list() {
+        return await this.sendRequest("storage/list", {});
+      }
+      /**
+       * Clear all data for this plugin instance
+       *
+       * @returns Number of entries deleted
+       */
+      async clear() {
+        return await this.sendRequest("storage/clear", {});
+      }
+      /**
+       * Handle an incoming JSON-RPC response line from the host.
+       *
+       * Call this method from your readline handler to deliver responses
+       * back to pending storage requests.
+       */
+      handleResponse(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+          return;
+        let parsed;
+        try {
+          parsed = JSON.parse(trimmed);
+        } catch {
+          return;
+        }
+        const obj = parsed;
+        if (obj.method !== void 0) {
+          return;
+        }
+        const id = obj.id;
+        if (id === void 0 || id === null)
+          return;
+        const pending = this.pendingRequests.get(id);
+        if (!pending)
+          return;
         this.pendingRequests.delete(id);
-        const message = err instanceof Error ? err.message : "Unknown write error";
-        reject(new StorageError(`Failed to send request: ${message}`, -1));
+        if ("error" in obj && obj.error) {
+          const err = obj.error;
+          pending.reject(new StorageError(err.message, err.code, err.data));
+        } else {
+          pending.resolve(obj.result);
+        }
       }
-    });
+      /**
+       * Cancel all pending requests (e.g. on shutdown).
+       */
+      cancelAll() {
+        for (const [, pending] of this.pendingRequests) {
+          pending.reject(new StorageError("Storage client stopped", -1));
+        }
+        this.pendingRequests.clear();
+      }
+      // ===========================================================================
+      // Internal
+      // ===========================================================================
+      sendRequest(method, params) {
+        const id = this.nextId++;
+        const request = {
+          jsonrpc: "2.0",
+          id,
+          method,
+          params
+        };
+        return new Promise((resolve, reject) => {
+          this.pendingRequests.set(id, { resolve, reject });
+          try {
+            this.writeFn(`${JSON.stringify(request)}
+`);
+          } catch (err) {
+            this.pendingRequests.delete(id);
+            const message = err instanceof Error ? err.message : "Unknown write error";
+            reject(new StorageError(`Failed to send request: ${message}`, -1));
+          }
+        });
+      }
+    };
   }
-};
+});
 
 // node_modules/@ashdev/codex-plugin-sdk/dist/server.js
+import { createInterface } from "node:readline";
 function validateStringFields(params, fields) {
   if (params === null || params === void 0) {
     return { field: "params", message: "params is required" };
@@ -766,6 +567,9 @@ async function handleRequest(request, manifest2, onInitialize, router, logger2,
       const initParams = params ?? {};
       initParams.storage = storage;
       initParams.hostRpc = hostRpc;
+      if (initParams.logLevel) {
+        logger2.setLevel(initParams.logLevel);
+      }
       if (onInitialize) {
         await onInitialize(initParams);
       }
@@ -785,115 +589,413 @@ async function handleRequest(request, manifest2, onInitialize, router, logger2,
       return null;
     }
   }
-  const response = await router(method, params, id);
-  if (response !== null) {
-    return response;
+  const response = await router(method, params, id);
+  if (response !== null) {
+    return response;
+  }
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+      message: `Method not found: ${method}`
+    }
+  };
+}
+function writeResponse(response) {
+  process.stdout.write(`${JSON.stringify(response)}
+`);
+}
+function methodNotFound(id, message) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+      message
+    }
+  };
+}
+function success(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function createMetadataPlugin(options) {
+  const { manifest: manifest2, provider, bookProvider: bookProvider2, onInitialize, logLevel } = options;
+  const contentTypes = manifest2.capabilities.metadataProvider;
+  if (contentTypes.includes("series") && !provider) {
+    throw new Error("Series metadata provider is required when 'series' is in metadataProvider capabilities");
+  }
+  if (contentTypes.includes("book") && !bookProvider2) {
+    throw new Error("Book metadata provider is required when 'book' is in metadataProvider capabilities");
+  }
+  const router = async (method, params, id) => {
+    switch (method) {
+      // Series metadata methods
+      case "metadata/series/search": {
+        if (!provider)
+          return methodNotFound(id, "This plugin does not support series metadata");
+        const err = validateSearchParams(params);
+        if (err)
+          return invalidParamsError(id, err);
+        return success(id, await provider.search(params));
+      }
+      case "metadata/series/get": {
+        if (!provider)
+          return methodNotFound(id, "This plugin does not support series metadata");
+        const err = validateGetParams(params);
+        if (err)
+          return invalidParamsError(id, err);
+        return success(id, await provider.get(params));
+      }
+      case "metadata/series/match": {
+        if (!provider)
+          return methodNotFound(id, "This plugin does not support series metadata");
+        if (!provider.match)
+          return methodNotFound(id, "This plugin does not support series match");
+        const err = validateMatchParams(params);
+        if (err)
+          return invalidParamsError(id, err);
+        return success(id, await provider.match(params));
+      }
+      // Book metadata methods
+      case "metadata/book/search": {
+        if (!bookProvider2)
+          return methodNotFound(id, "This plugin does not support book metadata");
+        const err = validateBookSearchParams(params);
+        if (err)
+          return invalidParamsError(id, err);
+        return success(id, await bookProvider2.search(params));
+      }
+      case "metadata/book/get": {
+        if (!bookProvider2)
+          return methodNotFound(id, "This plugin does not support book metadata");
+        const err = validateGetParams(params);
+        if (err)
+          return invalidParamsError(id, err);
+        return success(id, await bookProvider2.get(params));
+      }
+      case "metadata/book/match": {
+        if (!bookProvider2)
+          return methodNotFound(id, "This plugin does not support book metadata");
+        if (!bookProvider2.match)
+          return methodNotFound(id, "This plugin does not support book match");
+        const err = validateBookMatchParams(params);
+        if (err)
+          return invalidParamsError(id, err);
+        return success(id, await bookProvider2.match(params));
+      }
+      default:
+        return null;
+    }
+  };
+  createPluginServer({ manifest: manifest2, onInitialize, logLevel, router });
+}
+var init_server = __esm({
+  "node_modules/@ashdev/codex-plugin-sdk/dist/server.js"() {
+    init_errors();
+    init_host_rpc();
+    init_logger();
+    init_request_context();
+    init_storage();
+    init_rpc();
+  }
+});
+
+// node_modules/@ashdev/codex-plugin-sdk/dist/types/manifest.js
+var init_manifest = __esm({
+  "node_modules/@ashdev/codex-plugin-sdk/dist/types/manifest.js"() {
+  }
+});
+
+// node_modules/@ashdev/codex-plugin-sdk/dist/types/releases.js
+var init_releases = __esm({
+  "node_modules/@ashdev/codex-plugin-sdk/dist/types/releases.js"() {
+  }
+});
+
+// node_modules/@ashdev/codex-plugin-sdk/dist/types/index.js
+var init_types = __esm({
+  "node_modules/@ashdev/codex-plugin-sdk/dist/types/index.js"() {
+    init_manifest();
+    init_releases();
+    init_rpc();
+  }
+});
+
+// node_modules/@ashdev/codex-plugin-sdk/dist/index.js
+var init_dist = __esm({
+  "node_modules/@ashdev/codex-plugin-sdk/dist/index.js"() {
+    init_errors();
+    init_host_rpc();
+    init_logger();
+    init_server();
+    init_storage();
+    init_types();
+  }
+});
+
+// src/logger.ts
+var logger;
+var init_logger2 = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    init_dist();
+    logger = createLogger({ name: "openlibrary", level: "info" });
+  }
+});
+
+// src/api.ts
+var api_exports = {};
+__export(api_exports, {
+  buildOpenLibraryUrl: () => buildOpenLibraryUrl,
+  clearCache: () => clearCache,
+  extractOlid: () => extractOlid,
+  getAuthor: () => getAuthor,
+  getCoverUrlById: () => getCoverUrlById,
+  getCoverUrlByIsbn: () => getCoverUrlByIsbn,
+  getCoverUrlByOlid: () => getCoverUrlByOlid,
+  getEditionByIsbn: () => getEditionByIsbn,
+  getWork: () => getWork,
+  getWorkEditions: () => getWorkEditions,
+  isValidIsbn: () => isValidIsbn,
+  normalizeIsbn: () => normalizeIsbn,
+  parseDescription: () => parseDescription,
+  parseLanguage: () => parseLanguage,
+  parseYear: () => parseYear,
+  searchBooks: () => searchBooks
+});
+function getCached(key) {
+  const entry = cache.get(key);
+  if (entry && Date.now() - entry.timestamp < CACHE_TTL_MS) {
+    return entry.data;
+  }
+  if (entry) {
+    cache.delete(key);
+  }
+  return null;
+}
+function setCache(key, data) {
+  cache.set(key, { data, timestamp: Date.now() });
+}
+async function fetchJson(url, description) {
+  const cached = getCached(url);
+  if (cached !== null) {
+    logger.debug(`cache hit: ${description}`);
+    return cached;
+  }
+  try {
+    logger.debug(`GET ${url} (${description})`);
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "Codex/1.0 (https://github.com/AshDevFr/codex; codex-plugin)",
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        logger.debug(`404 not found: ${description}`);
+        return null;
+      }
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    setCache(url, data);
+    logger.debug(`${response.status} OK, cached: ${description}`);
+    return data;
+  } catch (error) {
+    logger.error(`Failed to fetch ${description}`, error);
+    return null;
+  }
+}
+function normalizeIsbn(isbn) {
+  return isbn.replace(/[-\s]/g, "").toUpperCase();
+}
+function isValidIsbn(isbn) {
+  const normalized = normalizeIsbn(isbn);
+  return normalized.length === 10 || normalized.length === 13;
+}
+async function getEditionByIsbn(isbn) {
+  const normalized = normalizeIsbn(isbn);
+  const url = `${BASE_URL}/isbn/${normalized}.json`;
+  return fetchJson(url, `edition by ISBN ${normalized}`);
+}
+async function getWork(workKey) {
+  const key = workKey.startsWith("/works/") ? workKey : `/works/${workKey}`;
+  const url = `${BASE_URL}${key}.json`;
+  return fetchJson(url, `work ${key}`);
+}
+async function getWorkEditions(workKey, limit = 5) {
+  const key = workKey.startsWith("/works/") ? workKey : `/works/${workKey}`;
+  const url = `${BASE_URL}${key}/editions.json?limit=${limit}`;
+  const response = await fetchJson(url, `editions for ${key}`);
+  return response?.entries || [];
+}
+async function getAuthor(authorKey) {
+  const key = authorKey.startsWith("/authors/") ? authorKey : `/authors/${authorKey}`;
+  const url = `${BASE_URL}${key}.json`;
+  return fetchJson(url, `author ${key}`);
+}
+async function searchBooks(query, options = {}) {
+  const { author, limit = 10 } = options;
+  if (author) {
+    const params2 = new URLSearchParams({
+      title: query,
+      author,
+      fields: SEARCH_FIELDS,
+      limit: String(limit)
+    });
+    const url2 = `${BASE_URL}/search.json?${params2}`;
+    const response = await fetchJson(
+      url2,
+      `search title="${query}" author="${author}"`
+    );
+    if (response?.docs?.length) {
+      return response;
+    }
+  }
+  const params = new URLSearchParams({
+    q: query,
+    fields: SEARCH_FIELDS,
+    limit: String(limit)
+  });
+  if (author) {
+    params.set("author", author);
   }
-  return {
-    jsonrpc: "2.0",
-    id,
-    error: {
-      code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
-      message: `Method not found: ${method}`
-    }
-  };
+  const url = `${BASE_URL}/search.json?${params}`;
+  return fetchJson(url, `search "${query}"`);
 }
-function writeResponse(response) {
-  process.stdout.write(`${JSON.stringify(response)}
-`);
+function getCoverUrlByIsbn(isbn, size) {
+  const normalized = normalizeIsbn(isbn);
+  return `${COVERS_BASE_URL}/b/isbn/${normalized}-${size}.jpg`;
 }
-function methodNotFound(id, message) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    error: {
-      code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
-      message
-    }
-  };
+function getCoverUrlById(coverId, size) {
+  return `${COVERS_BASE_URL}/b/id/${coverId}-${size}.jpg`;
 }
-function success(id, result) {
-  return { jsonrpc: "2.0", id, result };
+function getCoverUrlByOlid(olid, size) {
+  const id = olid.replace(/^\/(?:books|works)\//, "");
+  return `${COVERS_BASE_URL}/b/olid/${id}-${size}.jpg`;
 }
-function createMetadataPlugin(options) {
-  const { manifest: manifest2, provider, bookProvider: bookProvider2, onInitialize, logLevel } = options;
-  const contentTypes = manifest2.capabilities.metadataProvider;
-  if (contentTypes.includes("series") && !provider) {
-    throw new Error("Series metadata provider is required when 'series' is in metadataProvider capabilities");
-  }
-  if (contentTypes.includes("book") && !bookProvider2) {
-    throw new Error("Book metadata provider is required when 'book' is in metadataProvider capabilities");
+function parseYear(dateStr) {
+  if (!dateStr) return void 0;
+  const match = dateStr.match(/(?:^|[^0-9])(1[89]\d{2}|20\d{2})(?:[^0-9]|$)/);
+  if (match) {
+    return Number.parseInt(match[1], 10);
   }
-  const router = async (method, params, id) => {
-    switch (method) {
-      // Series metadata methods
-      case "metadata/series/search": {
-        if (!provider)
-          return methodNotFound(id, "This plugin does not support series metadata");
-        const err = validateSearchParams(params);
-        if (err)
-          return invalidParamsError(id, err);
-        return success(id, await provider.search(params));
-      }
-      case "metadata/series/get": {
-        if (!provider)
-          return methodNotFound(id, "This plugin does not support series metadata");
-        const err = validateGetParams(params);
-        if (err)
-          return invalidParamsError(id, err);
-        return success(id, await provider.get(params));
-      }
-      case "metadata/series/match": {
-        if (!provider)
-          return methodNotFound(id, "This plugin does not support series metadata");
-        if (!provider.match)
-          return methodNotFound(id, "This plugin does not support series match");
-        const err = validateMatchParams(params);
-        if (err)
-          return invalidParamsError(id, err);
-        return success(id, await provider.match(params));
-      }
-      // Book metadata methods
-      case "metadata/book/search": {
-        if (!bookProvider2)
-          return methodNotFound(id, "This plugin does not support book metadata");
-        const err = validateBookSearchParams(params);
-        if (err)
-          return invalidParamsError(id, err);
-        return success(id, await bookProvider2.search(params));
-      }
-      case "metadata/book/get": {
-        if (!bookProvider2)
-          return methodNotFound(id, "This plugin does not support book metadata");
-        const err = validateGetParams(params);
-        if (err)
-          return invalidParamsError(id, err);
-        return success(id, await bookProvider2.get(params));
-      }
-      case "metadata/book/match": {
-        if (!bookProvider2)
-          return methodNotFound(id, "This plugin does not support book metadata");
-        if (!bookProvider2.match)
-          return methodNotFound(id, "This plugin does not support book match");
-        const err = validateBookMatchParams(params);
-        if (err)
-          return invalidParamsError(id, err);
-        return success(id, await bookProvider2.match(params));
-      }
-      default:
-        return null;
-    }
+  return void 0;
+}
+function parseDescription(desc) {
+  if (!desc) return void 0;
+  const raw = typeof desc === "string" ? desc : desc.value;
+  return stripHtml(raw);
+}
+function stripHtml(html) {
+  let text = html;
+  text = text.replace(/<\/(p|div|li|tr|h[1-6])>/gi, "\n");
+  text = text.replace(/<br\s*\/?>/gi, "\n");
+  text = text.replace(/<[^>]+>/g, "");
+  text = text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&apos;/g, "'").replace(/&nbsp;/g, " ");
+  text = text.replace(/[^\S\n]+/g, " ");
+  text = text.replace(/\n{3,}/g, "\n\n");
+  text = text.split("\n").map((line) => line.trim()).join("\n").trim();
+  return text || void 0;
+}
+function parseLanguage(langRef) {
+  if (!langRef) return void 0;
+  const match = langRef.match(/\/languages\/(\w+)$/);
+  if (!match) return void 0;
+  const code = match[1].toLowerCase();
+  const languageMap = {
+    eng: "en",
+    spa: "es",
+    fre: "fr",
+    fra: "fr",
+    ger: "de",
+    deu: "de",
+    ita: "it",
+    por: "pt",
+    rus: "ru",
+    jpn: "ja",
+    chi: "zh",
+    zho: "zh",
+    kor: "ko",
+    ara: "ar",
+    hin: "hi",
+    pol: "pl",
+    tur: "tr",
+    dut: "nl",
+    nld: "nl",
+    swe: "sv",
+    nor: "no",
+    dan: "da",
+    fin: "fi",
+    cze: "cs",
+    ces: "cs",
+    gre: "el",
+    ell: "el",
+    heb: "he",
+    hun: "hu",
+    rom: "ro",
+    ron: "ro",
+    tha: "th",
+    vie: "vi",
+    ind: "id",
+    mal: "ms",
+    msa: "ms",
+    ukr: "uk",
+    cat: "ca",
+    lat: "la"
   };
-  createPluginServer({ manifest: manifest2, onInitialize, logLevel, router });
+  return languageMap[code] || code;
+}
+function extractOlid(key) {
+  return key.replace(/^\/(?:works|books|authors)\//, "");
+}
+function buildOpenLibraryUrl(key) {
+  return `${BASE_URL}${key.startsWith("/") ? key : `/${key}`}`;
 }
+function clearCache() {
+  cache.clear();
+}
+var BASE_URL, COVERS_BASE_URL, CACHE_TTL_MS, cache, SEARCH_FIELDS;
+var init_api = __esm({
+  "src/api.ts"() {
+    "use strict";
+    init_logger2();
+    BASE_URL = "https://openlibrary.org";
+    COVERS_BASE_URL = "https://covers.openlibrary.org";
+    CACHE_TTL_MS = 15 * 60 * 1e3;
+    cache = /* @__PURE__ */ new Map();
+    SEARCH_FIELDS = [
+      "key",
+      "title",
+      "subtitle",
+      "author_name",
+      "author_key",
+      "first_publish_year",
+      "publish_year",
+      "publisher",
+      "isbn",
+      "number_of_pages_median",
+      "cover_i",
+      "cover_edition_key",
+      "edition_count",
+      "language",
+      "subject",
+      "ratings_average",
+      "ratings_count"
+    ].join(",");
+  }
+});
 
 // src/index.ts
+init_dist();
 init_api();
+init_logger2();
 
 // package.json
 var package_default = {
   name: "@ashdev/codex-plugin-metadata-openlibrary",
-  version: "1.37.0",
+  version: "1.38.0",
   description: "Open Library metadata plugin for Codex - fetches book metadata by ISBN or title search",
   main: "dist/index.js",
   bin: "dist/index.js",
@@ -933,7 +1035,7 @@ var package_default = {
     node: ">=22.0.0"
   },
   dependencies: {
-    "@ashdev/codex-plugin-sdk": "^1.37.0"
+    "@ashdev/codex-plugin-sdk": "^1.38.0"
   },
   devDependencies: {
     "@biomejs/biome": "^2.4.4",
@@ -1240,7 +1342,6 @@ async function getFullBookMetadata(editionOrWorkKey, isbn) {
 }
 
 // src/index.ts
-var logger = createLogger({ name: "openlibrary", level: "info" });
 var config = {
   maxResults: DEFAULT_MAX_RESULTS
 };
@@ -1254,6 +1355,9 @@ var bookProvider = {
   async search(params) {
     const { isbn, query, author, limit } = params;
     const maxResults = Math.min(limit || config.maxResults, 50);
+    logger.debug(
+      `search: isbn=${isbn ?? "-"} query=${JSON.stringify(query ?? "")} author=${JSON.stringify(author ?? "")} maxResults=${maxResults}`
+    );
     if (isbn && isValidIsbn(isbn)) {
       const edition = await getEditionByIsbn(isbn);
       if (edition) {
@@ -1290,8 +1394,12 @@ var bookProvider = {
       limit: maxResults
     });
     if (!searchResponse?.docs?.length) {
+      logger.debug(`search: no results for query=${JSON.stringify(query)}`);
       return { results: [] };
     }
+    logger.debug(
+      `search: ${searchResponse.docs.length} result(s) for query=${JSON.stringify(query)}`
+    );
     return {
       results: searchResponse.docs.map(mapSearchDocToSearchResult)
     };
@@ -1305,10 +1413,12 @@ var bookProvider = {
    */
   async get(params) {
     const { externalId } = params;
+    logger.debug(`get: externalId=${externalId}`);
     const metadata = await getFullBookMetadata(externalId);
     if (metadata) {
       return metadata;
     }
+    logger.debug(`get: no full metadata for ${externalId}, returning minimal record`);
     return {
       externalId,
       externalUrl: `https://openlibrary.org${externalId.startsWith("/") ? externalId : `/${externalId}`}`,
@@ -1341,9 +1451,13 @@ var bookProvider = {
    */
   async match(params) {
     const { title, authors, isbn, year } = params;
+    logger.debug(
+      `match: title=${JSON.stringify(title)} authors=${JSON.stringify(authors ?? [])} isbn=${isbn ?? "-"} year=${year ?? "-"}`
+    );
     if (isbn && isValidIsbn(isbn)) {
       const edition = await getEditionByIsbn(isbn);
       if (edition) {
+        logger.debug(`match: ISBN ${isbn} resolved directly (confidence 0.99)`);
         const workKey = edition.works?.[0]?.key;
         const workData = workKey ? await getWork(workKey) : null;
         const metadata = await mapEditionToBookMetadata(edition, workData);
@@ -1391,6 +1505,9 @@ var bookProvider = {
       confidence = Math.min(1, confidence + 0.1);
     }
     confidence = Math.min(confidence, 0.85);
+    logger.debug(
+      `match: best=${JSON.stringify(bestMatch.title)} confidence=${confidence.toFixed(2)} (${results.length} candidate(s))`
+    );
     return {
       match: bestMatch,
       confidence,
@@ -1403,6 +1520,7 @@ createMetadataPlugin({
   bookProvider,
   logLevel: "info",
   onInitialize(params) {
+    if (params.logLevel) logger.setLevel(params.logLevel);
     const maxResults = params.adminConfig?.maxResults;
     if (maxResults !== void 0) {
       config.maxResults = Math.min(Math.max(1, maxResults), 50);