tablefacts 0.1.0

package/src/menu/lib/run.mjs

@@ -0,0 +1,83 @@
+// The command every menu source is: extract, check, write to Supabase.
+// A source script (src/menu/<source>/extract.mjs) only says how to get the
+// menu; the flags, the checks and the write are the same for all of them.
+import { parseArgs } from "node:util";
+import { loadEnv } from "../../lib/env.mjs";
+import { cliMessage, exitCodeFor } from "../../lib/errors.mjs";
+import { importMenu } from "./import.mjs";
+
+/** The option names the menu library uses in its messages, as the flags the CLI shows. */
+export const menuFlags = {
+  only: "--only",
+  provider: "--provider",
+  model: "--model",
+  minWidth: "--min-width",
+  replaceAll: "--replace-all",
+  force: "--force",
+  dryRun: "--dry-run",
+};
+
+/** A library message with option names turned into flags. */
+export const flagText = (message) => cliMessage({ message }, menuFlags);
+
+/**
+ * The CLI's logger: info and warn lines (progress, notes, "left untouched") go to stdout as
+ * they always did, errors to stderr, and option names in the text become flags.
+ */
+export const cliLog = (message, level = "info") => {
+  const text = flagText(message);
+  if (level === "error") console.error(text);
+  else console.log(text);
+};
+
+const commonOptions = `
+Options:
+  --dry-run       extract and check, show what would change, write nothing
+  --json <file>   also save the extracted menu as JSON
+  --replace-all   replace the whole menu, not only the categories in this import
+  --force         write even if the import has far fewer products than it replaces
+  -h, --help      show this help
+
+The database is SUPABASE_DB_URL in .env (see .env.example).
+`;
+
+/**
+ * `fetchMenu({ values, positionals })` returns `{ menu, notes, title }`: the
+ * menu in the shape of lib/menu.mjs, what the source wants the user to know,
+ * and a heading. `options` are the source's own flags, in util.parseArgs form.
+ */
+export async function runImport({ usage, options = {}, fetchMenu }) {
+  try {
+    const { values, positionals } = parseArgs({
+      args: process.argv.slice(2),
+      allowPositionals: true,
+      options: {
+        "dry-run": { type: "boolean" },
+        json: { type: "string" },
+        "replace-all": { type: "boolean" },
+        force: { type: "boolean" },
+        help: { type: "boolean", short: "h" },
+        ...options,
+      },
+    });
+    if (values.help) {
+      console.log(usage + commonOptions);
+      return;
+    }
+
+    loadEnv();
+    const fetched = await fetchMenu({ values, positionals });
+    await importMenu({
+      ...fetched,
+      dryRun: !!values["dry-run"],
+      json: values.json,
+      replaceAll: !!values["replace-all"],
+      force: !!values.force,
+      log: cliLog,
+    });
+  } catch (error) {
+    console.error(`
+${cliMessage(error, menuFlags)}`);
+    process.exitCode = exitCodeFor(error);
+  }
+}

package/src/menu/raw/config.mjs

@@ -0,0 +1,38 @@
+// Everything restaurant-specific about the image-menu import. Edit this file,
+// not the other scripts, when the menu is organised differently.
+export default {
+  // The page that shows the menu pictures, or direct image URLs.
+  // `tablefacts menu raw <url> [<url>...]` overrides it for one run.
+  url: "https://www.mombasa.co/carta-restaurante-espanol/",
+
+  // Currency of the prices, an ISO code. Colombian menus print pesos as
+  // "$95.000": "." groups thousands and "," marks decimals.
+  currency: "COP",
+  thousands: ".",
+  decimal: ",",
+  // Multiply every price by this when the menu prints thousands short ("95"
+  // for 95.000).
+  scale: 1,
+
+  // Each section the model reads is tagged food or drink (or other, which is
+  // left out), and goes into the category that lists its group. The site's
+  // default categories are cocina and bar.
+  categories: [
+    { slug: "cocina", name: "Comida", groups: ["food"] },
+    { slug: "bar", name: "Bebidas", groups: ["drink"] },
+  ],
+
+  // Section title (ignoring case and accents) > category slug, for a section
+  // the model tagged wrongly.
+  placeIn: {},
+
+  // Section title > the name stored, for ones that should not just be the
+  // title in UPPERCASE. "COCTELES DE AUTOR" is what the home page cocktail
+  // list reads (signatureMenu in content/site.ts).
+  sections: {
+    "Cócteles de Autor": "COCTELES DE AUTOR",
+  },
+
+  // Section titles to leave out entirely.
+  skipSections: [],
+};

package/src/menu/raw/extract.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+// Imports a restaurant's menu from pictures of its pages into the Supabase
+// menu tables. See src/menu/README.md. Run from the project's folder:
+//   tablefacts menu raw --list
+//   tablefacts menu raw --dry-run
+import { parseArgs } from "node:util";
+import { cliLog, menuFlags, runImport } from "../lib/run.mjs";
+import { cliMessage, exitCodeFor } from "../../lib/errors.mjs";
+import { fetchImageMenu, findPages } from "./import.mjs";
+import { defaultProvider, providers } from "./vision.mjs";
+
+const providerNames = Object.keys(providers).join(", ");
+const providerTable = Object.entries(providers)
+  .map(([name, { keyName, defaultModel }]) => `  ${name.padEnd(10)} ${keyName.padEnd(18)} ${defaultModel}`)
+  .join("\n");
+
+const usage = `Usage: tablefacts menu raw [page-or-image-url...] [options]
+
+Reads a menu that is only pictures (one image per page) by transcribing each
+page with a vision model, and replaces the menu in Supabase.
+The URLs are pages to scan for menu images, or direct image URLs
+(default: config.mjs). The key of the provider that reads the pages goes in
+.env:
+
+  provider   key                default model
+${providerTable}
+
+Image menu options:
+  --list              show the pictures found and stop; nothing is read or written
+  --only <pages>      only these pages, numbered as --list shows them (e.g. 1,3-5)
+  --provider <name>   who reads the pages: ${providerNames}
+                      (default: MENU_VISION_PROVIDER in .env, else ${defaultProvider})
+  --model <id>        model of that provider (default: see the table)
+  --min-width <px>    ignore images declaring a smaller width (default: 500)
+  --refresh           read the pages again instead of using the saved transcriptions`;
+
+const shared = {
+  "min-width": { type: "string", default: "500" },
+  only: { type: "string" },
+};
+
+if (process.argv.includes("--list")) {
+  try {
+    const { values, positionals } = parseArgs({ args: process.argv.slice(2), allowPositionals: true, options: { ...shared, list: { type: "boolean" }, help: { type: "boolean", short: "h" } }, strict: false });
+    const { pages, chosen } = await findPages({ urls: positionals, only: values.only, minWidth: values["min-width"] });
+    console.log(`${pages.length} images found:\n`);
+    for (const page of chosen) console.log(`  ${String(page.number).padStart(2)}  ${page.url}${page.alt ? `\n      ${page.alt.slice(0, 100)}` : ""}`);
+  } catch (error) {
+    console.error(`\n${cliMessage(error, menuFlags)}`);
+    process.exitCode = exitCodeFor(error);
+  }
+} else {
+  await runImport({
+    usage,
+    options: {
+      ...shared,
+      provider: { type: "string" },
+      model: { type: "string" },
+      refresh: { type: "boolean" },
+    },
+    fetchMenu: ({ values, positionals }) =>
+      fetchImageMenu({
+        urls: positionals,
+        only: values.only,
+        provider: values.provider, // else MENU_VISION_PROVIDER, which loadEnv has read by now
+        model: values.model,
+        minWidth: values["min-width"],
+        refresh: values.refresh,
+        log: cliLog,
+      }),
+  });
+}

package/src/menu/raw/import.mjs

@@ -0,0 +1,99 @@
+// Menus that are only pictures, as a library: find the pages, have a vision
+// model transcribe them (saved in the cache), normalize and import.
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { resolveEnv } from "../../lib/env.mjs";
+import { optionError, TablefactsError } from "../../lib/errors.mjs";
+import { normalizeLog } from "../../lib/log.mjs";
+import { importMenu } from "../lib/import.mjs";
+import defaultConfig from "./config.mjs";
+import { normalizePages } from "./normalize.mjs";
+import { discoverPages, downloadPage } from "./source.mjs";
+import { defaultProvider, providers, readPage } from "./vision.mjs";
+
+const providerNames = Object.keys(providers).join(", ");
+
+/** "1,3-5" (or a list of numbers) to Set {1,3,4,5}. */
+function pageSet(only) {
+  if (Array.isArray(only)) return new Set(only.map(Number));
+  const wanted = new Set();
+  for (const part of String(only).split(",")) {
+    const m = part.trim().match(/^(\d+)(?:-(\d+))?$/);
+    if (!m) throw optionError("only", `\`only\` "${only}" is not a list of pages such as 1,3-5.`);
+    for (let n = Number(m[1]); n <= Number(m[2] ?? m[1]); n++) wanted.add(n);
+  }
+  return wanted;
+}
+
+/** Every image found, and the numbered ones `only` selects. `config` defaults to config.mjs. */
+export async function findPages({ urls = [], only, minWidth = 500, config = defaultConfig } = {}) {
+  if (!urls.length && !config.url) throw new TablefactsError("No menu page to read: pass urls, or set url in the raw menu config.", "ECONFIG");
+  const pages = await discoverPages(urls.length ? urls : [config.url], { minWidth: Number(minWidth) });
+  const wanted = only === undefined || only === "" ? null : pageSet(only);
+  const chosen = pages.map((page, i) => ({ ...page, number: i + 1 })).filter((page) => !wanted || wanted.has(page.number));
+  if (!chosen.length) throw optionError("only", `\`only\` ${only} matches none of the ${pages.length} pages found.`);
+  return { pages, chosen };
+}
+
+/**
+ * The pictures the CLI's `--list` prints, numbered. `only` narrows them.
+ * @param {import('../../lib/types.mjs').ListMenuImagesOptions} [options]
+ * @returns {Promise<import('../../lib/types.mjs').MenuImage[]>}
+ */
+export async function listMenuImages(options = {}) {
+  return (await findPages(options)).chosen;
+}
+
+/** Reads the pages and normalizes them: `{ menu, notes, title }`, ready for importMenu. */
+export async function fetchImageMenu({ urls = [], only, provider, model, minWidth = 500, refresh = false, apiKey, env, projectDir, config = defaultConfig, log: logOption } = {}) {
+  const log = normalizeLog(logOption);
+  provider = String(provider || resolveEnv(env).MENU_VISION_PROVIDER || defaultProvider).toLowerCase();
+  if (!Object.hasOwn(providers, provider)) throw optionError("provider", `Unknown provider "${provider}" (from \`provider\` or MENU_VISION_PROVIDER). Use one of: ${providerNames}.`, "ECONFIG");
+  model ||= providers[provider].defaultModel;
+
+  const { chosen } = await findPages({ urls, only, minWidth, config });
+  const host = new URL(urls[0] ?? config.url).hostname;
+
+  const transcriptions = new Array(chosen.length);
+  let next = 0;
+  let reading = 0;
+  const worker = async () => {
+    while (next < chosen.length) {
+      const slot = next++;
+      const page = chosen[slot];
+      const local = await downloadPage(page, host, { projectDir });
+      const cached = join(local.dir, `${local.id}.json`);
+      const saved = refresh ? null : await readFile(cached, "utf8").catch((error) => {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      });
+      if (saved !== null) {
+        transcriptions[slot] = JSON.parse(saved);
+        continue;
+      }
+      reading++;
+      log(`Reading page ${page.number}...`);
+      transcriptions[slot] = await readPage(local, { provider, model, apiKey, env });
+      await writeFile(cached, JSON.stringify(transcriptions[slot], null, 2) + "\n");
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(3, chosen.length) }, worker));
+
+  const { menu, notes, currency } = normalizePages(transcriptions.map((t, i) => ({ ...t, number: chosen[i].number })), config);
+  notes.unshift(`Prices were read from pictures: check them against the menu before writing. Transcriptions are saved in .tablefacts/cache/${host}/ (edit a .json there to fix a page, then run again).`);
+  return {
+    menu,
+    notes,
+    title: `Image menu: ${chosen.length} pages from ${host} (${reading} read with ${providers[provider].label} ${model}, ${chosen.length - reading} from the saved transcriptions), prices in ${currency}`,
+  };
+}
+
+/**
+ * Reads the menu from pictures with a vision model and imports it. Takes importMenu's options too.
+ * @param {import('../../lib/types.mjs').ImportImageMenuOptions} [options]
+ * @returns {Promise<import('../../lib/types.mjs').ImportResult>}
+ */
+export async function importImageMenu({ urls, only, provider, model, minWidth, refresh, apiKey, env, config, ...importOptions } = {}) {
+  const fetched = await fetchImageMenu({ urls, only, provider, model, minWidth, refresh, apiKey, env, config, projectDir: importOptions.projectDir, log: importOptions.log });
+  return importMenu({ ...fetched, ...importOptions, env });
+}

package/src/menu/raw/normalize.mjs

@@ -0,0 +1,120 @@
+// Transcribed menu pages (vision.mjs) to the shape lib/menu.mjs describes.
+import { cleanText, isCurrency, matchKey, sectionName } from "../lib/menu.mjs";
+import { TablefactsError } from "../../lib/errors.mjs";
+
+/**
+ * "$95.000" to 95000. `thousands` and `decimal` are the separators the menu
+ * prints (Colombia: "." and ","); `scale` multiplies the result for menus that
+ * print "95" meaning 95.000. Returns null for text with no number.
+ * @param {string} text
+ * @param {import('../../lib/types.mjs').PriceFormat} [format]
+ * @returns {number | null}
+ */
+export function parsePrice(text, { thousands = ".", decimal = ",", scale = 1 } = {}) {
+  let digits = String(text ?? "").replace(/[^\d.,]/g, "");
+  if (!/\d/.test(digits)) return null;
+  digits = digits.split(thousands).join("").replace(decimal, ".");
+  const value = Number(digits);
+  if (!Number.isFinite(value)) return null;
+  return Math.round(value * scale * 100) / 100;
+}
+
+const listNames = (names) => names.slice(0, 6).join(", ") + (names.length > 6 ? `, and ${names.length - 6} more` : "");
+
+/**
+ * `pages` is the transcription of each page, in page order. A section with no
+ * title continues the section before it (a list that runs onto the next page),
+ * and sections with the same title are merged. Each section is placed in the
+ * category of `config.categories` that lists its group (food, drink), unless
+ * `config.placeIn` names it. An item with several priced columns becomes one
+ * product per column, "Name (Botella)", because a product has one price.
+ * @param {{ number?: number, notes?: string[], sections?: any[] }[]} pages transcriptions, one per page
+ * @param {import('../../lib/types.mjs').RawConfig} config
+ * @returns {{ menu: import('../../lib/types.mjs').Menu, notes: string[], currency: string }}
+ */
+export function normalizePages(pages, config) {
+  const notes = [];
+  const currency = String(config.currency ?? "").toUpperCase();
+  if (!isCurrency(currency)) throw new TablefactsError(`config.currency "${config.currency}" is not a currency code (such as COP or USD).`, "ECONFIG");
+
+  const categories = (config.categories ?? []).map((c) => ({ ...c, sections: new Map() }));
+  const bySlug = new Map(categories.map((c) => [c.slug, c]));
+  const byGroup = new Map(categories.flatMap((c) => (c.groups ?? []).map((group) => [group, c])));
+  const renames = new Map(Object.entries(config.sections ?? {}).map(([from, to]) => [matchKey(from), to]));
+  const placeIn = new Map(Object.entries(config.placeIn ?? {}).map(([from, slug]) => [matchKey(from), slug]));
+  const skip = new Set((config.skipSections ?? []).map(matchKey));
+  for (const slug of placeIn.values()) if (!bySlug.has(slug)) throw new TablefactsError(`config.placeIn points at "${slug}", which is not in config.categories.`, "ECONFIG");
+
+  const unparsed = [];
+  const unlabeled = [];
+  const skipped = [];
+  let previous = null; // the last section placed: { category, name }
+
+  pages.forEach((page, index) => {
+    const label = `page ${page.number ?? index + 1}`;
+    for (const note of page.notes ?? []) notes.push(`${label}: ${cleanText(note)}`);
+    for (const section of page.sections ?? []) {
+      const title = cleanText(section.title);
+      const items = (section.items ?? []).filter((item) => cleanText(item.name));
+      if (!items.length) continue;
+
+      let target;
+      if (!title) {
+        if (!previous) {
+          notes.push(`${label}: ${items.length} items come before any section heading, so they were skipped: ${listNames(items.map((i) => i.name))}.`);
+          continue;
+        }
+        target = previous;
+      } else {
+        if (skip.has(matchKey(title))) {
+          skipped.push(title);
+          continue;
+        }
+        const category = bySlug.get(placeIn.get(matchKey(title))) ?? byGroup.get(section.group);
+        if (!category) {
+          skipped.push(`${title} (${section.group})`);
+          continue;
+        }
+        target = { category, name: renames.get(matchKey(title)) ?? sectionName(title) };
+      }
+
+      const { category, name } = target;
+      if (!category.sections.has(name)) category.sections.set(name, []);
+      const products = category.sections.get(name);
+      for (const item of items) {
+        const itemName = cleanText(item.name);
+        const prices = (item.prices ?? []).map((p) => ({ value: parsePrice(p.text, config), label: cleanText(p.label) })).filter((p) => p.value !== null);
+        if (!prices.length) {
+          unparsed.push(`${itemName} (${label})`);
+          continue;
+        }
+        const variants = prices.length > 1 && prices.every((p) => p.label) ? prices : prices.slice(0, 1);
+        if (prices.length > 1 && variants.length === 1) unlabeled.push(itemName);
+        for (const { value, label: variant } of variants) {
+          products.push({
+            name: variants.length > 1 ? `${itemName} (${variant})` : itemName,
+            description: cleanText(item.description) || null,
+            price: value,
+            currency,
+            image_url: null,
+            recommended: false,
+          });
+        }
+      }
+      previous = target;
+    }
+  });
+
+  if (skipped.length) notes.push(`Sections not placed in any category and left out: ${listNames([...new Set(skipped)])}. Add them to config.categories groups, config.placeIn or config.skipSections.`);
+  if (unparsed.length) notes.push(`${unparsed.length} items have no readable price and were left out: ${listNames(unparsed)}.`);
+  if (unlabeled.length) notes.push(`${unlabeled.length} items show several prices without saying what each is for, so only the first was imported: ${listNames(unlabeled)}.`);
+
+  const menu = categories
+    .map((c) => ({
+      slug: c.slug,
+      name: c.name,
+      sections: [...c.sections].filter(([, list]) => list.length).map(([name, list]) => ({ name, products: list })),
+    }))
+    .filter((c) => c.sections.length);
+  return { menu, notes, currency };
+}

package/src/menu/raw/source.mjs

@@ -0,0 +1,116 @@
+// Finds the menu pages of a restaurant whose menu is only pictures (a gallery
+// of JPGs on a WordPress page, a menu photographed page by page) and downloads
+// them. Nothing here is specific to one site: it takes the large images of a
+// page's HTML in document order. Sites that load their pictures from
+// JavaScript show up as "no images": pass the image URLs directly instead.
+import { createHash } from "node:crypto";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { TablefactsError } from "../../lib/errors.mjs";
+import { workDirIn } from "../../lib/project.mjs";
+
+const headers = { "user-agent": "cannario-menu-sync/1.0 (restaurant menu importer)" };
+const IMAGE = /\.(jpe?g|png|webp)(\?|$)/i;
+const MAX_BYTES = 5 * 1024 * 1024; // the Claude API refuses larger images; Gemini and Groq take 20 MB, so this is the tightest limit
+
+async function get(url, what) {
+  let failure;
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      const res = await fetch(url, { headers, signal: AbortSignal.timeout(30_000) });
+      if (res.ok) return res;
+      failure = Object.assign(new TablefactsError(`HTTP ${res.status} fetching ${what} ${url}`, "EFAILED"), { status: res.status });
+      if (res.status < 500) break;
+    } catch (error) {
+      failure = error;
+    }
+    await new Promise((resolve) => setTimeout(resolve, attempt * 1000));
+  }
+  throw failure;
+}
+
+const attribute = (tag, name) => tag.match(new RegExp(`\\s${name}\\s*=\\s*("([^"]*)"|'([^']*)')`, "i"))?.slice(2).find((v) => v !== undefined);
+
+/** WordPress serves "name-600x1199.jpg" next to the original "name.jpg": ask for the original. */
+const original = (url) => url.replace(/-\d{2,4}x\d{2,4}(\.\w+)(\?|$)/, "$1$2");
+
+/**
+ * The picture URLs of a page, in document order. Lazy-loaders keep the real
+ * address in data-orig-src / data-src and put a placeholder in src, so those
+ * come first. Images declaring a width under `minWidth` (logos, icons) and
+ * anything that is not a JPG, PNG or WebP (SVG logos) are skipped.
+ */
+export function findImages(html, pageUrl, { minWidth = 500 } = {}) {
+  const found = new Map();
+  for (const [tag] of html.matchAll(/<img\b[^>]*>/gi)) {
+    const raw = [attribute(tag, "data-orig-src"), attribute(tag, "data-src"), attribute(tag, "src")].find((v) => v && !v.startsWith("data:"));
+    if (!raw) continue;
+    let url;
+    try {
+      url = original(new URL(raw.replace(/&amp;/g, "&"), pageUrl).href);
+    } catch {
+      continue;
+    }
+    if (!IMAGE.test(url)) continue;
+    const width = Number(attribute(tag, "width"));
+    if (width && width < minWidth) continue;
+    if (!found.has(url)) found.set(url, { url, alt: attribute(tag, "alt") ?? "" });
+  }
+  return [...found.values()];
+}
+
+/** Each argument is a page to scan or a direct image URL. */
+export async function discoverPages(inputs, options) {
+  for (const input of inputs) {
+    try {
+      new URL(input);
+    } catch {
+      throw new TablefactsError(`"${input}" is not a URL.`, "EUSAGE");
+    }
+  }
+  const found = await Promise.allSettled(
+    inputs.map(async (input) => {
+      if (IMAGE.test(new URL(input).pathname)) return [{ url: input, alt: "" }];
+      const html = await (await get(input, "page")).text();
+      const images = findImages(html, input, options);
+      if (!images.length) {
+        throw new TablefactsError(
+          `No menu images found in ${input} (looked for JPG, PNG or WebP at least ${options?.minWidth ?? 500}px wide).\n` +
+            "If the page loads its pictures with JavaScript, open it, copy the image addresses and pass them instead; use `minWidth` to lower the size filter.",
+          "EFAILED",
+        );
+      }
+      return images;
+    }),
+  );
+  const failed = found.find((r) => r.status === "rejected");
+  if (failed) throw failed.reason; // the first input's failure, whichever finished first
+  return found.flatMap((r) => r.value);
+}
+
+export const pageId = (url) => createHash("sha1").update(url).digest("hex").slice(0, 10);
+
+/** Downloads one page image into the cache (once) and returns where it is and what it is. */
+export async function downloadPage(page, host, { projectDir } = {}) {
+  const dir = join(workDirIn(projectDir, "cache"), host);
+  await mkdir(dir, { recursive: true });
+  const id = pageId(page.url);
+  const meta = join(dir, `${id}.type`);
+  const types = { "image/jpeg": "jpg", "image/png": "png", "image/webp": "webp" };
+  // The saved media type names the extension, so a cache hit is one read and one access check.
+  const saved = await readFile(meta, "utf8").catch(() => null);
+  if (saved && types[saved]) {
+    const known = join(dir, `${id}.${types[saved]}`);
+    if (await access(known).then(() => true, () => false)) return { id, dir, file: known, mediaType: saved };
+  }
+
+  const res = await get(page.url, "image");
+  const mediaType = (res.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
+  if (!types[mediaType]) throw new TablefactsError(`${page.url} is ${mediaType || "of unknown type"}, not a JPG, PNG or WebP image.`, "EFAILED");
+  const bytes = Buffer.from(await res.arrayBuffer());
+  if (bytes.length > MAX_BYTES) throw new TablefactsError(`${page.url} is ${(bytes.length / 1048576).toFixed(1)} MB; menu pages are limited to 5 MB so that every provider can read them. Save a smaller copy.`, "EFAILED");
+  const file = join(dir, `${id}.${types[mediaType]}`);
+  await writeFile(file, bytes);
+  await writeFile(meta, mediaType);
+  return { id, dir, file, mediaType };
+}