mcp-recipes 1.0.0

package/dist/sources/client.js

@@ -0,0 +1,697 @@
+// src/version.ts
+var PKG_VERSION = "1.0.0";
+var REPO_URL = "https://github.com/smeet666/mcp-recipes";
+var ISSUES_URL = "https://github.com/smeet666/mcp-recipes/issues";
+
+// src/config.ts
+var LOG_LEVELS = ["silent", "error", "info", "debug"];
+var DEFAULT_INTERVAL_MS = 1e3;
+var MIN_ALLOWED_INTERVAL_MS = 500;
+var MAX_ALLOWED_INTERVAL_MS = 6e4;
+var DEFAULT_USER_AGENT = `mcp-recipes/${PKG_VERSION} (+${REPO_URL})`;
+function createLogger(level) {
+  const rank = LOG_LEVELS.indexOf(level);
+  const write = (at, message) => {
+    if (rank === 0 || LOG_LEVELS.indexOf(at) > rank) return;
+    process.stderr.write(`[mcp-recipes] ${at}: ${message}
+`);
+  };
+  return {
+    debug: (m) => write("debug", m),
+    info: (m) => write("info", m),
+    // A warning goes out at the error level so it survives the default
+    // setting: a caller has to know that a site was left out of an answer.
+    warn: (m) => write("error", m),
+    error: (m) => write("error", m)
+  };
+}
+function readInteger(env, name, fallback, min, max) {
+  const raw = env[name];
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || !Number.isInteger(value)) {
+    process.stderr.write(
+      `[mcp-recipes] error: ${name}="${raw}" is not a whole number; using ${fallback}.
+`
+    );
+    return fallback;
+  }
+  if (value < min || value > max) {
+    process.stderr.write(
+      `[mcp-recipes] error: ${name}=${value} is outside ${min}..${max}; using ${fallback}.
+`
+    );
+    return fallback;
+  }
+  return value;
+}
+function loadConfig(env = process.env) {
+  const level = env.RECIPES_LOG_LEVEL;
+  const logLevel = level && LOG_LEVELS.includes(level) ? level : "error";
+  if (level && !LOG_LEVELS.includes(level)) {
+    process.stderr.write(
+      `[mcp-recipes] error: RECIPES_LOG_LEVEL="${level}" is not one of ${LOG_LEVELS.join(", ")}; using error.
+`
+    );
+  }
+  const custom = env.RECIPES_USER_AGENT?.trim();
+  return {
+    // A caller who wants to be recognised may say who they are, and the
+    // contact address stays attached: a site has to be able to reach a human
+    // about traffic it did not expect.
+    userAgent: custom ? `${custom} ${DEFAULT_USER_AGENT}` : DEFAULT_USER_AGENT,
+    minIntervalMs: readInteger(
+      env,
+      "RECIPES_MIN_INTERVAL_MS",
+      DEFAULT_INTERVAL_MS,
+      MIN_ALLOWED_INTERVAL_MS,
+      MAX_ALLOWED_INTERVAL_MS
+    ),
+    timeoutMs: readInteger(env, "RECIPES_TIMEOUT_MS", 2e4, 1e3, 12e4),
+    maxRetries: readInteger(env, "RECIPES_MAX_RETRIES", 3, 0, 8),
+    cacheTtlMs: readInteger(env, "RECIPES_CACHE_TTL_MS", 9e5, 0, 864e5),
+    cacheMaxEntries: readInteger(env, "RECIPES_CACHE_MAX_ENTRIES", 200, 1, 5e3),
+    logLevel
+  };
+}
+
+// src/errors.ts
+var ERROR_CODES = [
+  "not_found",
+  "invalid_input",
+  "rate_limited",
+  "parse_failure",
+  "network_error",
+  "timeout"
+];
+var RecipesError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "RecipesError";
+    this.code = code;
+    this.details = details;
+  }
+};
+var invalidInput = (message, hint) => new RecipesError("invalid_input", message, hint ? { hint } : {});
+var parseFailure = (message, details) => new RecipesError("parse_failure", message, {
+  hint: `A site may have changed how it answers. Please report this at ${ISSUES_URL} with the arguments you used.`,
+  ...details
+});
+var timeout = (message, details) => new RecipesError("timeout", message, details ?? {});
+function toRecipesError(error) {
+  if (error instanceof RecipesError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  const raw = error;
+  const code = typeof raw?.code === "string" ? raw.code : "";
+  const known = ERROR_CODES.find((candidate) => candidate === code);
+  const details = raw && typeof raw.details === "object" && raw.details !== null ? raw.details : {};
+  return new RecipesError(known ?? "network_error", message, details);
+}
+
+// src/sources/adapter.ts
+function text(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+function textList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function count(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function required(value, field, source) {
+  const found = text(value);
+  if (found === null) {
+    throw parseFailure(
+      `${source.name} answered without a readable "${field}", so there is no recipe to return.`
+    );
+  }
+  return found;
+}
+function rowsOf(value, source) {
+  if (!Array.isArray(value)) {
+    throw parseFailure(
+      `${source.name} answered in a shape this server could not read: the list of results was missing.`
+    );
+  }
+  return value;
+}
+function namespacedId(source, reference) {
+  return `${source}:${reference}`;
+}
+function publishedFigures(panel) {
+  if (typeof panel !== "object" || panel === null) return null;
+  const kept = {};
+  for (const [key, value] of Object.entries(panel)) {
+    if (typeof value === "string" && value.trim() !== "") kept[key] = value.trim();
+  }
+  return Object.keys(kept).length > 0 ? kept : null;
+}
+function readYieldSpan(published) {
+  if (published === null) return { count: null, max: null, unit: null };
+  const span = /^\s*(\d+(?:[.,]\d+)?)\s*(?:à|a|to|-|–|—|ou|or)\s*(\d+(?:[.,]\d+)?)\s*(.*)$/i.exec(
+    published
+  );
+  if (span) {
+    const low = Number(span[1].replace(",", "."));
+    const high = Number(span[2].replace(",", "."));
+    if (Number.isFinite(low) && Number.isFinite(high) && high > low) {
+      return { count: low, max: high, unit: text(span[3]) };
+    }
+  }
+  const single = /^\s*(\d+(?:[.,]\d+)?)\s*(.*)$/.exec(published);
+  if (single) {
+    const value = Number(single[1].replace(",", "."));
+    if (Number.isFinite(value)) return { count: value, max: null, unit: text(single[2]) };
+  }
+  return { count: null, max: null, unit: null };
+}
+function detailBase(source) {
+  return {
+    source: source.id,
+    sourceName: source.name,
+    language: source.language,
+    attribution: source.attribution
+  };
+}
+
+// src/sources/ids.ts
+var SEPARATOR = ":";
+function resolveId(rawId, sources) {
+  const trimmed = rawId.trim();
+  if (trimmed === "") {
+    throw invalidInput(
+      "A recipe identifier is required.",
+      `Use one of the ids search_recipes returned, such as ${example(sources)}.`
+    );
+  }
+  for (const source of sources) {
+    const prefix = `${source.id}${SEPARATOR}`;
+    if (!trimmed.toLowerCase().startsWith(prefix.toLowerCase())) continue;
+    const reference = trimmed.slice(prefix.length).trim();
+    if (reference === "") {
+      throw invalidInput(
+        `"${trimmed}" names a source and no recipe.`,
+        "Put the source's own identifier after the colon."
+      );
+    }
+    return { source, reference, inferred: null };
+  }
+  const claimed = sources.map((source) => ({ source, claim: source.claims(trimmed) })).filter(
+    (entry) => Boolean(entry.claim)
+  );
+  if (claimed.length > 1) {
+    throw invalidInput(
+      `"${trimmed}" could be an identifier on ${names(claimed.map((entry) => entry.source))}, so it names no one recipe.`,
+      `Spell it with its source, as in ${claimed.map((entry) => `${entry.source.id}:${trimmed}`).join(" or ")}.`
+    );
+  }
+  const only = claimed[0];
+  if (!only) {
+    throw invalidInput(
+      `"${trimmed}" is not an identifier any of the sources this server reads would mint.`,
+      `Call search_recipes with "${trimmed}" as the query and pass an id from a row, which reads like ${example(sources)}.`
+    );
+  }
+  return {
+    source: only.source,
+    reference: only.claim.reference,
+    inferred: only.claim.guess ? `${only.claim.why}, which is a guess: check the recipe that comes back is the one you meant` : only.claim.why
+  };
+}
+function names(sources) {
+  const all = sources.map((source) => source.name);
+  if (all.length <= 1) return all.join("");
+  return `${all.slice(0, -1).join(", ")} and ${all[all.length - 1]}`;
+}
+function example(sources) {
+  const first = sources[0];
+  return first ? `${first.id}${SEPARATOR}<the source's own id>` : "<source>:<id>";
+}
+
+// src/sources/registry.ts
+import { MarmitonClient } from "mcp-marmiton/client";
+import { CookbookClient } from "mcp-wikibooks-cookbook/client";
+
+// src/sources/cookbook.ts
+var COOKBOOK_PROFILE = {
+  id: "cookbook",
+  name: "Wikibooks Cookbook",
+  homeUrl: "https://en.wikibooks.org/wiki/Cookbook:Table_of_Contents",
+  language: "en",
+  attribution: "Source: Wikibooks Cookbook",
+  // The namespace holds pages about salt and about a dish made with it alike.
+  mixesReferencePages: true
+};
+var SITE_URL = /^https?:\/\/en\.wikibooks\.org\/wiki\//i;
+var NAMESPACE = /^cookbook\s*:/i;
+function dishName(title) {
+  return title.replace(NAMESPACE, "").trim() || title;
+}
+function cookbookAdapter(reader) {
+  return {
+    ...COOKBOOK_PROFILE,
+    claims(raw) {
+      if (SITE_URL.test(raw)) {
+        let key;
+        try {
+          key = decodeURIComponent(raw.replace(SITE_URL, "")).replace(/_/g, " ");
+        } catch {
+          throw invalidInput(
+            `"${raw}" carries a percent sign that is not a valid escape, so the page name cannot be read.`,
+            "Pass the id search_recipes returned instead of the address."
+          );
+        }
+        return {
+          reference: key,
+          why: "the address is a page on the English Wikibooks",
+          guess: false
+        };
+      }
+      if (NAMESPACE.test(raw)) {
+        return {
+          reference: raw,
+          why: "the name opens with the namespace every Cookbook page lives under",
+          guess: false
+        };
+      }
+      return null;
+    },
+    async search(query, limit) {
+      const outcome = await reader.search(query, limit);
+      const list = rowsOf(
+        outcome.data?.results,
+        COOKBOOK_PROFILE
+      );
+      const rows = [];
+      let skipped = 0;
+      for (const summary of list) {
+        const key = text(summary?.key);
+        const title = text(summary?.title) ?? key;
+        const url = text(summary?.sourceUrl);
+        if (!key || !title || !url) {
+          skipped += 1;
+          continue;
+        }
+        rows.push({
+          id: namespacedId(COOKBOOK_PROFILE.id, key),
+          source: COOKBOOK_PROFILE.id,
+          sourceName: COOKBOOK_PROFILE.name,
+          title: dishName(title),
+          url,
+          imageUrl: text(summary?.imageUrl),
+          excerpt: text(summary?.excerpt) ?? text(summary?.description)
+        });
+      }
+      return {
+        rows,
+        skipped,
+        // The gateway states no total and offers no second page, so there is no
+        // number to report. Counting the rows returned and calling it a total
+        // would invent one.
+        reportedTotal: null,
+        reportedTotalMeans: null,
+        cached: outcome.cached
+      };
+    },
+    async getRecipe(reference) {
+      const outcome = await reader.getRecipe(reference);
+      return { recipe: cookbookDetail(outcome.data), cached: outcome.cached };
+    }
+  };
+}
+function cookbookDetail(payload) {
+  const recipe = payload ?? {};
+  const license = recipe.license;
+  const licenseTitle = text(license?.title);
+  const licenseUrl = text(license?.url);
+  const published = text(recipe.yieldText);
+  const span = readYieldSpan(published);
+  return {
+    ...detailBase(COOKBOOK_PROFILE),
+    id: namespacedId(COOKBOOK_PROFILE.id, required(recipe.key, "key", COOKBOOK_PROFILE)),
+    title: dishName(required(recipe.title ?? recipe.key, "title", COOKBOOK_PROFILE)),
+    url: required(recipe.sourceUrl, "url", COOKBOOK_PROFILE),
+    // The page source carries no picture this server can address.
+    imageUrl: null,
+    yieldCount: count(recipe.servings) ?? span.count,
+    yieldMax: span.max,
+    yieldText: published,
+    yieldUnit: text(recipe.yieldUnit) ?? span.unit,
+    ingredients: textList(recipe.ingredients),
+    steps: textList(recipe.steps),
+    // The Cookbook publishes one time for a recipe rather than splitting it.
+    prepMinutes: null,
+    cookMinutes: null,
+    totalMinutes: count(recipe.totalMinutes),
+    category: text(recipe.category),
+    // The page is written by everyone who edited it, so it credits nobody in
+    // particular and carries no reader rating.
+    author: null,
+    rating: null,
+    nutrition: publishedFigures(recipe.nutrition),
+    equipment: textList(recipe.equipment),
+    tips: textList(recipe.tips),
+    // A licence is only stated when both halves of it arrived: a name with no
+    // address, or an address with no name, is not terms anyone can follow.
+    license: licenseTitle && licenseUrl ? { title: licenseTitle, url: licenseUrl } : null
+  };
+}
+
+// src/sources/marmiton.ts
+var MARMITON_PROFILE = {
+  id: "marmiton",
+  name: "Marmiton",
+  homeUrl: "https://www.marmiton.org",
+  language: "fr",
+  attribution: "Source: Marmiton",
+  // Every page the search returns is a recipe.
+  mixesReferencePages: false
+};
+var SITE_URL2 = /^https?:\/\/(?:www\.)?marmiton\.org\//i;
+var REFERENCE = /^\d+$/;
+function marmitonAdapter(reader) {
+  return {
+    ...MARMITON_PROFILE,
+    claims(raw) {
+      if (SITE_URL2.test(raw)) {
+        return { reference: raw, why: "the address is a Marmiton page", guess: false };
+      }
+      if (REFERENCE.test(raw)) {
+        return {
+          reference: raw,
+          why: "a bare number is the shape Marmiton mints",
+          guess: false
+        };
+      }
+      return null;
+    },
+    async search(query) {
+      const outcome = await reader.search(query);
+      const list = rowsOf(outcome.data, MARMITON_PROFILE);
+      const rows = [];
+      let skipped = 0;
+      for (const summary of list) {
+        const id = text(summary?.id);
+        const title = text(summary?.title);
+        const url = text(summary?.url);
+        if (!id || !title || !url) {
+          skipped += 1;
+          continue;
+        }
+        rows.push({
+          id: namespacedId(MARMITON_PROFILE.id, id),
+          source: MARMITON_PROFILE.id,
+          sourceName: MARMITON_PROFILE.name,
+          title,
+          url,
+          imageUrl: text(summary?.imageUrl),
+          // The result list carries a title and a picture and no prose, so
+          // there is nothing to quote here.
+          excerpt: null
+        });
+      }
+      return {
+        rows,
+        skipped,
+        // Rows on the page, including the ones this server could not read: the
+        // site saw them, and reporting only the readable ones would understate
+        // what it holds.
+        reportedTotal: rows.length + skipped,
+        reportedTotalMeans: "rows on the single page of results Marmiton serves; the site disallows paging, so this is not a catalogue count",
+        cached: outcome.cached
+      };
+    },
+    async getRecipe(reference) {
+      const ref = /^https?:\/\//i.test(reference) ? { url: reference } : { id: reference };
+      const outcome = await reader.getRecipe(ref);
+      return { recipe: marmitonDetail(outcome.data), cached: outcome.cached };
+    }
+  };
+}
+function marmitonDetail(payload) {
+  const recipe = payload ?? {};
+  const yields = recipe.recipeYield ?? {};
+  const rating = recipe.rating;
+  const value = count(rating?.value);
+  const published = text(yields.text);
+  const span = readYieldSpan(published);
+  return {
+    ...detailBase(MARMITON_PROFILE),
+    id: namespacedId(MARMITON_PROFILE.id, required(recipe.id, "id", MARMITON_PROFILE)),
+    title: required(recipe.title, "title", MARMITON_PROFILE),
+    url: required(recipe.url, "url", MARMITON_PROFILE),
+    imageUrl: text(recipe.imageUrl),
+    yieldCount: span.count ?? count(yields.count),
+    yieldMax: span.max,
+    yieldText: published,
+    yieldUnit: span.unit ?? text(yields.unit),
+    ingredients: textList(recipe.ingredients),
+    steps: textList(recipe.steps),
+    prepMinutes: count(recipe.prepMinutes),
+    cookMinutes: count(recipe.cookMinutes),
+    totalMinutes: count(recipe.totalMinutes),
+    category: text(recipe.category),
+    author: text(recipe.author),
+    rating: value === null ? null : { value, count: count(rating?.count), max: count(rating?.best) },
+    nutrition: publishedFigures(recipe.nutrition),
+    equipment: [],
+    tips: [],
+    // Marmiton states no licence on a recipe page, and silence is not a grant.
+    license: null
+  };
+}
+
+// src/sources/registry.ts
+var SOURCE_IDS = [MARMITON_PROFILE.id, COOKBOOK_PROFILE.id];
+function buildSources(config, readers = {}) {
+  const shared = {
+    userAgent: config.userAgent,
+    minIntervalMs: config.minIntervalMs,
+    timeoutMs: config.timeoutMs,
+    maxRetries: config.maxRetries,
+    cacheTtlMs: config.cacheTtlMs,
+    cacheMaxEntries: config.cacheMaxEntries,
+    logLevel: config.logLevel
+  };
+  const marmitonOptions = { config: shared };
+  const cookbookOptions = { config: shared };
+  return [
+    marmitonAdapter(readers.marmiton ?? new MarmitonClient(marmitonOptions)),
+    cookbookAdapter(readers.cookbook ?? new CookbookClient(cookbookOptions))
+  ];
+}
+function selectSources(sources, wanted) {
+  if (!wanted) return sources;
+  const unknown = wanted.filter((id) => !sources.some((source) => source.id === id));
+  if (unknown.length > 0) {
+    throw invalidInput(
+      `This server reads no source called ${unknown.map((id) => `"${id}"`).join(", ")}.`,
+      `It reads ${sources.map((source) => source.id).join(", ")}.`
+    );
+  }
+  const chosen = sources.filter((source) => wanted.includes(source.id));
+  if (chosen.length === 0) {
+    throw invalidInput(
+      "A search needs at least one source.",
+      `Name one of ${sources.map((source) => source.id).join(", ")}, or leave the argument out to ask them all.`
+    );
+  }
+  return chosen;
+}
+
+// src/sources/client.ts
+var MAX_LIMIT_PER_SOURCE = 25;
+function withGuarantees(config) {
+  const defaults = loadConfig({});
+  const bounded = (value, fallback, min, max) => {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) return fallback;
+    return Math.min(max, Math.max(min, parsed));
+  };
+  const claimed = typeof config.userAgent === "string" ? config.userAgent.trim() : "";
+  const identifier = defaults.userAgent;
+  return {
+    ...config,
+    userAgent: claimed === "" || claimed.includes(identifier) ? identifier : `${claimed} ${identifier}`,
+    minIntervalMs: bounded(
+      config.minIntervalMs,
+      defaults.minIntervalMs,
+      MIN_ALLOWED_INTERVAL_MS,
+      MAX_ALLOWED_INTERVAL_MS
+    ),
+    timeoutMs: bounded(config.timeoutMs, defaults.timeoutMs, 1e3, 12e4),
+    maxRetries: bounded(config.maxRetries, defaults.maxRetries, 0, 8),
+    cacheTtlMs: bounded(config.cacheTtlMs, defaults.cacheTtlMs, 0, 864e5),
+    cacheMaxEntries: bounded(config.cacheMaxEntries, defaults.cacheMaxEntries, 1, 5e3),
+    logLevel: config.logLevel ?? defaults.logLevel
+  };
+}
+function withDeadline(work, ms, source) {
+  let timer;
+  const alarm = new Promise((_resolve, reject) => {
+    timer = setTimeout(
+      () => reject(
+        timeout(
+          `${source.name} did not answer within ${ms}ms and was left out of this answer.`
+        )
+      ),
+      ms
+    );
+    timer.unref?.();
+  });
+  return Promise.race([work, alarm]).finally(() => clearTimeout(timer));
+}
+function reportOf(attempt, count2) {
+  return {
+    source: attempt.source.id,
+    name: attempt.source.name,
+    status: attempt.error ? "failed" : "answered",
+    count: count2,
+    reportedTotal: attempt.reportedTotal,
+    reportedTotalMeans: attempt.reportedTotalMeans,
+    skipped: attempt.skipped,
+    mixesReferencePages: attempt.source.mixesReferencePages,
+    cached: attempt.cached,
+    error: attempt.error
+  };
+}
+function interleave(groups) {
+  const merged = [];
+  const longest = Math.max(0, ...groups.map((group) => group.length));
+  for (let index = 0; index < longest; index += 1) {
+    for (const group of groups) {
+      const row = group[index];
+      if (row) merged.push(row);
+    }
+  }
+  return merged;
+}
+var RecipesClient = class {
+  config;
+  logger;
+  sources;
+  constructor(options = {}) {
+    this.config = withGuarantees({ ...loadConfig(), ...options.config });
+    this.logger = options.logger ?? createLogger(this.config.logLevel);
+    this.sources = options.sources ?? buildSources(this.config, options.readers ?? {});
+  }
+  /** What every source sees this client call itself. */
+  get userAgent() {
+    return this.config.userAgent;
+  }
+  get intervalMs() {
+    return this.config.minIntervalMs;
+  }
+  get timeoutMs() {
+    return this.config.timeoutMs;
+  }
+  get maxRetries() {
+    return this.config.maxRetries;
+  }
+  /** The sources this server reads, in the order an answer takes them. */
+  get profiles() {
+    return this.sources.map((source) => ({
+      id: source.id,
+      name: source.name,
+      language: source.language,
+      homeUrl: source.homeUrl
+    }));
+  }
+  /**
+   * The backstop deadline over one source, covering every attempt it is
+   * entitled to make and the pacing between them.
+   */
+  get deadlineMs() {
+    const attempts = this.config.maxRetries + 1;
+    return this.config.timeoutMs * attempts + this.config.minIntervalMs * this.config.maxRetries;
+  }
+  /**
+   * Ask every source the same question and merge the rows.
+   *
+   * The calls go out together, so the answer takes as long as the slowest
+   * source rather than as long as all of them. Whichever of them fail, the rest
+   * still come back, and the report says which was which.
+   */
+  async searchRecipes(query, limitPerSource, wanted) {
+    const trimmed = query.trim();
+    if (trimmed === "") {
+      throw invalidInput("A search needs something to look for.", "Name a dish or an ingredient.");
+    }
+    const chosen = selectSources(this.sources, wanted);
+    const limit = Math.max(1, Math.min(MAX_LIMIT_PER_SOURCE, Math.trunc(limitPerSource)));
+    const attempts = await Promise.all(
+      chosen.map((source) => this.searchOne(source, trimmed, limit))
+    );
+    const groups = attempts.map((attempt) => attempt.rows.slice(0, limit));
+    return {
+      rows: interleave(groups),
+      reports: attempts.map((attempt, index) => reportOf(attempt, groups[index].length))
+    };
+  }
+  async searchOne(source, query, limit) {
+    try {
+      const read = await withDeadline(source.search(query, limit), this.deadlineMs, source);
+      if (read.skipped > 0) {
+        this.logger.warn(
+          `${source.name} sent ${read.skipped} row(s) this server could not read; they were left out.`
+        );
+      }
+      return {
+        source,
+        rows: read.rows,
+        cached: read.cached,
+        reportedTotal: read.reportedTotal,
+        reportedTotalMeans: read.reportedTotalMeans,
+        skipped: read.skipped,
+        error: null
+      };
+    } catch (error) {
+      const known = toRecipesError(error);
+      this.logger.warn(`${source.name} did not answer: [${known.code}] ${known.message}`);
+      return {
+        source,
+        rows: [],
+        cached: false,
+        reportedTotal: null,
+        reportedTotalMeans: null,
+        skipped: 0,
+        error: {
+          code: known.code,
+          message: known.message,
+          ...known.details.hint ? { hint: known.details.hint } : {}
+        }
+      };
+    }
+  }
+  /**
+   * Read one recipe, from whichever source the identifier names.
+   *
+   * Only that source is called. Trying another after a miss would turn "this
+   * source has no page by this name" into somebody else's recipe with a
+   * different title, which is a worse answer than the absence it replaced.
+   */
+  async getRecipe(id) {
+    const read = resolveId(id, this.sources);
+    try {
+      const outcome = await withDeadline(
+        read.source.getRecipe(read.reference),
+        this.deadlineMs,
+        read.source
+      );
+      return { recipe: outcome.recipe, cached: outcome.cached, read };
+    } catch (error) {
+      throw toRecipesError(error);
+    }
+  }
+};
+export {
+  MAX_LIMIT_PER_SOURCE,
+  RecipesClient,
+  SOURCE_IDS,
+  interleave,
+  namespacedId,
+  resolveId
+};
+//# sourceMappingURL=client.js.map