tablefacts 0.1.0 → 0.2.0

package/src/research/lib/social.mjs

@@ -1,44 +1,155 @@
 // Instagram, TripAdvisor and link-in-bio hubs. All three are best-effort: they
 // sit behind login walls or bot protection, so each one returns what it could
 // read plus a `blocked` reason, and the report says what is missing.
-import { fetchText } from "./util.mjs";
+import { fetchText, sleep, decodeHtml as decodeEntities } from "./util.mjs";
 import { readPage } from "./website.mjs";
 
-/**
- * Public Instagram profile metadata. Without a login the page only exposes the
- * share card: "1,234 Followers, 56 Following, 789 Posts - Name (@handle) on
- * Instagram: "bio"". The bio often carries the phone, the area and a hub link.
- */
-export async function readInstagram(handle) {
-  const url = `https://www.instagram.com/${handle}/`;
-  let r;
-  try { r = await fetchText(url, { headers: { accept: "text/html" } }); } catch (e) { return { handle, url, blocked: e.message }; }
-  if (!r.ok) return { handle, url, blocked: `HTTP ${r.status}` };
-  const meta = (key) => r.text.match(new RegExp(`<meta[^>]+(?:property|name)=["']${key}["'][^>]+content=["']([^"']*)["']`, "i"))?.[1] ?? "";
-  const desc = meta("og:description").replace(/&quot;/g, '"').replace(/&#039;|&#x27;/g, "'").replace(/&amp;/g, "&");
-  const title = meta("og:title");
-  if (!desc && !title) return { handle, url, blocked: "login wall (no public metadata)" };
+// Instagram's own web app sends this app id with its public profile request; no
+// login is involved, and the request identifies honestly.
+const IG_APP_ID = "936619743392459";
+// A short gap between the Instagram surfaces: one walled profile should not become a burst.
+const SURFACE_PAUSE = 300;
+
+const bioLinks = (bio) => (bio.match(/https?:\/\/[^\s)]+|\b[\w-]+\.(?:com|co|link|bio|ee)\/[\w./-]+/gi) ?? [])
+  .map((l) => (/^https?:/.test(l) ? l : `https://${l}`));
+const bioPhones = (bio) => [...bio.matchAll(/\+?\d[\d\s().-]{7,}\d/g)].map((m) => m[0].trim());
+
+/** The public share card: "1,234 Followers, 56 Following, 789 Posts - Name (@handle) on Instagram: "bio"". */
+function shareCard(html) {
+  const meta = (key) => html.match(new RegExp(`<meta[^>]+(?:property|name)=["']${key}["'][^>]+content=["']([^"']*)["']`, "i"))?.[1] ?? "";
+  const desc = decodeEntities(meta("og:description"));
+  const title = decodeEntities(meta("og:title"));
+  if (!desc && !title) return null;
+  return { title, desc, image: meta("og:image") };
+}
+
+function fromCard(handle, url, card, surface) {
+  const desc = card.desc;
   const stats = desc.match(/([\d.,KMkm]+)\s+Followers?,\s*([\d.,KMkm]+)\s+Following,\s*([\d.,KMkm]+)\s+Posts?/i);
-  const bio = desc.match(/on Instagram:\s*["“]([\s\S]*?)["”]?\s*$/i)?.[1]?.trim() ?? "";
-  const links = bio.match(/https?:\/\/[^\s)]+|\b[\w-]+\.(?:com|co|link|bio|ee)\/[\w./-]+/gi) ?? [];
+  const wrapped = desc.match(/on Instagram:\s*["“]([\s\S]*?)["”]?\s*$/i)?.[1]?.trim();
+  // A bare bio snippet has no share-card wrapper; a stats-only line has no bio.
+  const bio = wrapped ?? (/Followers?,\s*[\d.,KMkm]+\s+Following/i.test(desc) ? "" : desc.trim());
   return {
-    handle, url,
-    displayName: title.replace(/\s*\(@.*$/, "").trim(),
+    handle, url, surface,
+    displayName: card.title.replace(/\s*\(@.*$/, "").trim(),
     followers: stats?.[1] ?? "",
     posts: stats?.[3] ?? "",
     bio,
-    phones: [...bio.matchAll(/\+?\d[\d\s().-]{7,}\d/g)].map((m) => m[0].trim()),
-    links: links.map((l) => (/^https?:/.test(l) ? l : `https://${l}`)),
-    image: meta("og:image"),
+    phones: bioPhones(bio),
+    links: bioLinks(bio),
+    image: card.image,
+  };
+}
+
+/** Fills in a missing bio or counts from the search-engine snippet, keeping whatever the surface itself gave. */
+function withSnippet(result, snippet) {
+  if (!snippet) return result;
+  const merged = fromCard(result.handle, result.url, { title: result.displayName ?? "", desc: snippet, image: result.image ?? "" }, result.surface);
+  return {
+    ...result,
+    followers: result.followers || merged.followers,
+    posts: result.posts || merged.posts,
+    bio: result.bio || merged.bio || snippet,
+    phones: result.phones?.length ? result.phones : merged.phones,
+    links: result.links?.length ? result.links : merged.links,
+  };
+}
+
+/** The public web_profile_info endpoint the profile page calls. No login, but often walled. */
+async function readProfileApi(handle) {
+  const url = `https://www.instagram.com/${handle}/`;
+  let r;
+  try { r = await fetchText(`https://www.instagram.com/api/v1/users/web_profile_info/?username=${encodeURIComponent(handle)}`, { headers: { accept: "application/json", "x-ig-app-id": IG_APP_ID } }); }
+  catch { return null; }
+  if (!r.ok) return null;
+  let user;
+  try { user = JSON.parse(r.text)?.data?.user; } catch { return null; }
+  if (!user) return null;
+  const bio = user.biography ?? "";
+  return {
+    handle, url, surface: "profile API",
+    displayName: user.full_name ?? "",
+    followers: user.edge_followed_by?.count != null ? String(user.edge_followed_by.count) : "",
+    posts: user.edge_owner_to_timeline_media?.count != null ? String(user.edge_owner_to_timeline_media.count) : "",
+    bio,
+    phones: bioPhones(bio),
+    links: bioLinks(bio),
+    image: user.profile_pic_url_hd ?? user.profile_pic_url ?? "",
   };
 }
 
-/** TripAdvisor: schema.org JSON-LD when the page loads; DataDome often blocks it. */
+/** oEmbed (public, though Instagram now usually wants an app token): display name only. */
+async function readOembed(handle, url) {
+  let r;
+  try { r = await fetchText(`https://api.instagram.com/oembed/?url=${encodeURIComponent(url)}`, { headers: { accept: "application/json" } }); }
+  catch { return null; }
+  if (!r.ok) return null;
+  let j;
+  try { j = JSON.parse(r.text); } catch { return null; }
+  if (!j?.author_name && !j?.title) return null;
+  return { handle, url, surface: "oembed", displayName: j.author_name ?? "", followers: "", posts: "", bio: "", phones: [], links: [], image: "" };
+}
+
+/**
+ * Public Instagram profile metadata, trying the public surfaces in turn: the
+ * share card, the web profile API, oEmbed, and finally the bio a search engine
+ * indexed (`snippet`). Only honest requests are made; a walled profile is
+ * reported as blocked, never worked around. Returns `blocked` only when none of
+ * them had anything.
+ */
+export async function readInstagram(handle, { snippet = "" } = {}) {
+  const url = `https://www.instagram.com/${handle}/`;
+  let reason = "";
+
+  try {
+    const r = await fetchText(url, { headers: { accept: "text/html" } });
+    if (!r.ok) reason = `HTTP ${r.status}`;
+    else {
+      const card = shareCard(r.text);
+      if (card) return withSnippet(fromCard(handle, url, card, "share card"), snippet);
+    }
+  } catch (e) { reason = e.message; }
+
+  await sleep(SURFACE_PAUSE);
+  const fromApi = await readProfileApi(handle);
+  if (fromApi) return withSnippet(fromApi, snippet);
+
+  await sleep(SURFACE_PAUSE);
+  const oembed = await readOembed(handle, url);
+  if (oembed) return withSnippet(oembed, snippet);
+
+  if (snippet) return { ...fromCard(handle, url, { title: "", desc: snippet, image: "" }, "search snippet"), partial: true };
+
+  return { handle, url, blocked: reason || "login wall (no public metadata on any surface)" };
+}
+
+/**
+ * Name and location out of a TripAdvisor restaurant URL slug, e.g.
+ * "...-Reviews-Maki_Bar_Medellin-Medellin_Antioquia_Department.html" gives
+ * { name: "Maki Bar Medellin", location: "Medellin Antioquia Department" }. The
+ * city/region boundary is ambiguous for multi-word cities, so the whole location
+ * is kept and the caller treats it as a hint, never as a confirmed locality.
+ */
+export function parseTripadvisorUrl(raw) {
+  let path;
+  try { path = new URL(raw).pathname; } catch { return null; }
+  const segment = path.split("/").find((s) => /-Reviews-|-ShowUserReviews-|-Management-/.test(s));
+  if (!segment) return null;
+  const after = segment.split(/-(?:Reviews|ShowUserReviews|Management)-/).pop()?.replace(/\.html?$/i, "") ?? "";
+  const [namePart = "", locationPart = ""] = after.split("-");
+  const words = (s) => decodeEntities(s).replace(/_/g, " ").replace(/\s+/g, " ").trim();
+  const name = words(namePart);
+  const location = words(locationPart);
+  return name ? { name, location } : null;
+}
+
+/** TripAdvisor: schema.org JSON-LD when the page loads; DataDome often blocks it. The URL slug is always kept. */
 export async function readTripadvisor(url, { browser } = {}) {
+  const slug = parseTripadvisorUrl(url);
   const { page, blocked } = await readPage(url, { browser });
-  if (!page) return { url, blocked };
-  if (!page.jsonld && page.textLength < 500) return { url, blocked: "bot protection (page has no data)" };
-  return { url: page.url, jsonld: page.jsonld, description: page.meta.description, hoursText: page.hoursText, images: page.images.slice(0, 10) };
+  if (!page) return { url, slug, blocked };
+  if (!page.jsonld && page.textLength < 500) return { url, slug, blocked: "bot protection (page has no data)" };
+  return { url: page.url, slug, jsonld: page.jsonld, description: page.meta.description, hoursText: page.hoursText, images: page.images.slice(0, 10) };
 }
 
 /** A link-in-bio hub (Linktree, Beacons, bio.link): its links, classified like a website's. */

package/src/research/lib/util.mjs

@@ -8,6 +8,28 @@ export const BROWSER_UA =
 
 export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
+const HTML_ENT = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " " };
+
+/** Decodes the HTML entities a page's attributes or text may hold, named and numeric. */
+export const decodeHtml = (s) => String(s).replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, e) => {
+  if (e[0] === "#") {
+    const n = e[1].toLowerCase() === "x" ? parseInt(e.slice(2), 16) : Number(e.slice(1));
+    return Number.isFinite(n) ? String.fromCodePoint(n) : m;
+  }
+  return HTML_ENT[e.toLowerCase()] ?? m;
+});
+
+// Instagram paths that are not a profile.
+export const IG_RESERVED = new Set(["p", "reel", "reels", "explore", "accounts", "tv", "stories", "share", "direct", "about", "legal", "web", "developer"]);
+
+/** The profile handle in an instagram.com URL, or "" for a post, reel or other non-profile path. */
+export const instagramHandle = (url) => {
+  try {
+    const h = new URL(url).pathname.split("/")[1]?.toLowerCase();
+    return h && !IG_RESERVED.has(h) && /^[a-z0-9._]+$/.test(h) ? h : "";
+  } catch { return ""; }
+};
+
 /** Runs `fn(item, index)` over `items` with at most `size` in flight; results keep the order of `items`. */
 export async function mapPool(items, size, fn) {
   const results = new Array(items.length);

package/src/research/lib/website.mjs

@@ -2,19 +2,9 @@
 // TripAdvisor page when it lets us in) with plain fetch and regexes: no HTML
 // parser dependency. Falls back to Playwright when a page renders client-side.
 import { loadPlaywright } from "../../lib/playwright.mjs";
-import { fetchText, sleep, BROWSER_UA } from "./util.mjs";
+import { fetchText, sleep, BROWSER_UA, decodeHtml as decode, instagramHandle } from "./util.mjs";
 import { fromOsm, fromSpec } from "./hours.mjs";
 
-const ENT = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " " };
-const decode = (s) =>
-  s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, e) => {
-    if (e[0] === "#") {
-      const n = e[1].toLowerCase() === "x" ? parseInt(e.slice(2), 16) : Number(e.slice(1));
-      return Number.isFinite(n) ? String.fromCodePoint(n) : m;
-    }
-    return ENT[e.toLowerCase()] ?? m;
-  });
-
 const attrs = (tag) => {
   const out = {};
   for (const m of tag.matchAll(/([a-zA-Z_:][-\w:.]*)\s*(?:=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g))
@@ -25,7 +15,6 @@ const abs = (u, base) => { try { return new URL(u, base).href; } catch { return
 const strip = (s) => decode(s.replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").trim();
 const host = (u) => { try { return new URL(u).hostname.replace(/^www\./, ""); } catch { return ""; } };
 
-const IG_RESERVED = new Set(["p", "reel", "reels", "explore", "accounts", "tv", "stories", "share", "direct", "about", "legal", "web", "developer"]);
 const RESERVE = /(opentable|resy\.com|thefork|eltenedor|exploretock|sevenrooms|covermanager|quandoo|tablein|mesa247|bookatable|tablecheck|resos\.com|reservandonos|agendapro|fudo\.)/i;
 const DELIVERY = /(rappi|ubereats|pedidosya|doordash|grubhub|domicilios\.com|didi-food|glovoapp)/i;
 const HUBS = /(linktr\.ee|beacons\.ai|bio\.link|lnk\.bio|linktree\.com|taplink|campsite\.bio|solo\.to|linkin\.bio|flow\.page)/i;
@@ -102,8 +91,8 @@ export function analyzeHtml(html, base, lines = visibleLines(html)) {
       const num = (u.pathname.match(/^\/(\d{7,})/)?.[1]) ?? u.searchParams.get("phone");
       push("whatsapp", num ? num.replace(/\D/g, "") : href);
     } else if (/(^|\.)instagram\.com$/.test(h)) {
-      const handle = u.pathname.split("/")[1]?.toLowerCase();
-      if (handle && !IG_RESERVED.has(handle) && /^[a-z0-9._]+$/.test(handle)) ig.set(handle, (ig.get(handle) ?? 0) + 1);
+      const handle = instagramHandle(href);
+      if (handle) ig.set(handle, (ig.get(handle) ?? 0) + 1);
     } else if (/facebook\.com$|fb\.com$/.test(h)) push("facebook", href);
     else if (/tiktok\.com$/.test(h)) push("tiktok", href);
     else if (/tripadvisor\./.test(h)) push("tripadvisor", href);

package/src/research/research.mjs

@@ -2,6 +2,7 @@
 // Usage: tablefacts research "Restaurant name" "City, Country" [options]
 import { parseArgs } from "node:util";
 import { research } from "./index.mjs";
+import { summaryLines } from "./lib/report.mjs";
 import { loadEnv } from "../lib/env.mjs";
 import { cliMessage, exitCodeFor } from "../lib/errors.mjs";
 import { consoleLog } from "../lib/log.mjs";
@@ -10,9 +11,11 @@ const HELP = `Research a restaurant from public sources and write a profile for
 
   tablefacts research "<name>" "<city, country>" [options]
 
-Sources: Google Maps (Places API), OpenStreetMap, the restaurant's website,
-Instagram, TripAdvisor and link-in-bio pages (Linktree and similar). They find
-each other: the website or Google leads to Instagram, TripAdvisor and the hub.
+Sources: Google Maps (Places API), OpenStreetMap, a key-free web search, the
+restaurant's website, Instagram, TripAdvisor and link-in-bio pages (Linktree
+and similar). They find each other: the search, website or Google leads to
+Instagram, TripAdvisor and the hub. The web search runs when Google and
+OpenStreetMap find nothing.
 
 Options:
   --country <ISO>       country code, narrows the search (CO, MX, US...)
@@ -26,8 +29,9 @@ Options:
   --out <dir>           output folder (default .tablefacts/research/<slug>)
   -h, --help            this text
 
-Writes profile.json, report.md and setup-answers.txt. GOOGLE_PLACES_API_KEY goes
-in .env (see .env.example); without it OpenStreetMap and the web pages
+Writes profile.json, report.md and setup-answers.txt (and latest.json next to the
+folder, in the default location). GOOGLE_PLACES_API_KEY goes in .env (see
+.env.example); without it OpenStreetMap, the web search and the web pages
 still work, with fewer facts.`;
 
 const { values, positionals } = parseArgs({
@@ -52,9 +56,9 @@ try {
     tripadvisor: values.tripadvisor, linktree: values.linktree, render: values.render,
     google: !values["no-google"], photos: Number(values.photos ?? 0), out: values.out, log: consoleLog,
   });
-  const found = Object.keys(profile.fields).filter((k) => profile.fields[k]);
-  console.log(`
-Found ${found.length} fields: ${found.join(", ")}`);
+  // The lines are built in one place (summaryLines) so tests cover the exact wording the CLI prints.
+  console.log();
+  for (const line of summaryLines(profile)) console.log(line);
   for (const w of profile.warnings) console.log(`Warning: ${w}`);
   console.log(`
 Wrote ${outDir}

package/types/lib/types.d.mts

@@ -253,7 +253,19 @@ export type ImportOptions = {
      */
     json?: string;
     /**
-     * Replace the whole menu, not only the categories in this import.
+     * This restaurant's table prefix (e.g. "makibar_"); empty for the unprefixed menu_* tables. Default "": importCluvi/importImageMenu fall back to the source config's.
+     */
+    tablePrefix?: string;
+    /**
+     * Write the unprefixed menu_* tables even when other restaurants' prefixed tables exist. Only for a single-restaurant database.
+     */
+    allowUnprefixed?: boolean;
+    /**
+     * Confirm a destructive `replaceAll`, which empties the target tables.
+     */
+    yes?: boolean;
+    /**
+     * Replace the whole menu, not only the categories in this import. Needs `yes`.
      */
     replaceAll?: boolean;
     /**
@@ -284,6 +296,7 @@ export type ImportResult = {
      */
     database: {
         label: string;
+        tables: string[];
         current: {
             categories: number;
             products: number;
@@ -297,6 +310,10 @@ export type ImportMenuOptions = ImportOptions & {
     title?: string;
 };
 export type CluviConfig = {
+    /**
+     * This restaurant's table prefix in a shared database (e.g. "cannario_"); empty for the unprefixed menu_* tables.
+     */
+    tablePrefix?: string;
     /**
      * Any page of the restaurant's Cluvi menu.
      */
@@ -315,6 +332,10 @@ export type CluviConfig = {
     sections?: Record<string, string>;
 };
 export type RawConfig = {
+    /**
+     * This restaurant's table prefix in a shared database (e.g. "mombasa_"); empty for the unprefixed menu_* tables.
+     */
+    tablePrefix?: string;
     /**
      * Page with the menu pictures, or a direct image URL.
      */
@@ -574,7 +595,10 @@ export type TablefactsErrorCode = 'EUSAGE' | 'ECONFIG' | 'EDEPENDENCY' | 'EFAILE
  * @typedef {object} ImportOptions
  * @property {boolean} [dryRun] Check and report, write nothing.
  * @property {string} [json] Also save the extracted menu as JSON at this path (resolved against projectDir).
- * @property {boolean} [replaceAll] Replace the whole menu, not only the categories in this import.
+ * @property {string} [tablePrefix] This restaurant's table prefix (e.g. "makibar_"); empty for the unprefixed menu_* tables. Default "": importCluvi/importImageMenu fall back to the source config's.
+ * @property {boolean} [allowUnprefixed] Write the unprefixed menu_* tables even when other restaurants' prefixed tables exist. Only for a single-restaurant database.
+ * @property {boolean} [yes] Confirm a destructive `replaceAll`, which empties the target tables.
+ * @property {boolean} [replaceAll] Replace the whole menu, not only the categories in this import. Needs `yes`.
  * @property {boolean} [force] Write even if the import has far fewer products than it replaces.
  * @property {string} [databaseUrl] Default: env.SUPABASE_DB_URL.
  * @property {Env} [env] Environment the database URL and keys are read from. Default process.env.
@@ -587,7 +611,7 @@ export type TablefactsErrorCode = 'EUSAGE' | 'ECONFIG' | 'EDEPENDENCY' | 'EFAILE
  * @property {string[]} notes
  * @property {boolean} written
  * @property {boolean} dryRun
- * @property {{ label: string, current: { categories: number, products: number, kept: string[] } } | null} database Null when the database was not reached.
+ * @property {{ label: string, tables: string[], current: { categories: number, products: number, kept: string[] } } | null} database Null when the database was not reached.
  */
 /**
  * @typedef {ImportOptions & { menu: Menu, notes?: string[], title?: string }} ImportMenuOptions
@@ -595,6 +619,7 @@ export type TablefactsErrorCode = 'EUSAGE' | 'ECONFIG' | 'EDEPENDENCY' | 'EFAILE
 /**
  * Restaurant-specific part of the Cluvi source (src/menu/cluvi/config.mjs).
  * @typedef {object} CluviConfig
+ * @property {string} [tablePrefix] This restaurant's table prefix in a shared database (e.g. "cannario_"); empty for the unprefixed menu_* tables.
  * @property {string} [url] Any page of the restaurant's Cluvi menu.
  * @property {{ slug: string, name: string, from: string[] }[]} [categories] Cluvi main categories folded into each site category.
  * @property {Record<string, string>} [sections] Cluvi subcategory to section name.
@@ -602,6 +627,7 @@ export type TablefactsErrorCode = 'EUSAGE' | 'ECONFIG' | 'EDEPENDENCY' | 'EFAILE
 /**
  * Restaurant-specific part of the picture-menu source (src/menu/raw/config.mjs).
  * @typedef {object} RawConfig
+ * @property {string} [tablePrefix] This restaurant's table prefix in a shared database (e.g. "mombasa_"); empty for the unprefixed menu_* tables.
  * @property {string} [url] Page with the menu pictures, or a direct image URL.
  * @property {string} currency ISO code of the prices.
  * @property {string} [thousands] Thousands separator the menu prints. Default ".".

package/types/menu/cluvi/config.d.mts

@@ -1,4 +1,5 @@
 declare const _default: {
+    tablePrefix: string;
     url: string;
     categories: {
         slug: string;

package/types/menu/cluvi/import.d.mts

@@ -4,6 +4,7 @@
  */
 export declare function fetchCluviMenu({ url, service, lang, config }?: {
     config?: {
+        tablePrefix: string;
         url: string;
         categories: {
             slug: string;
@@ -26,6 +27,7 @@ export declare function fetchCluviMenu({ url, service, lang, config }?: {
     }[];
     notes: string[];
     title: string;
+    tablePrefix: string;
 }>;
 /**
  * Reads the menu from Cluvi and imports it. Takes importMenu's options too.

package/types/menu/lib/db.d.mts

@@ -3,19 +3,47 @@ export declare function connect(url: any, { env }?: {}): Promise<{
     client: any;
     label: string;
 }>;
+/**
+ * Refuses to touch another site's tables before anything is written.
+ *
+ * Checks the three target tables exist (pointing at the migration when they do not). Then, when
+ * no prefix is set, lists the other restaurants' `<prefix>_menu_categories` tables: any of them
+ * means this database is shared, so the import stops unless the caller confirmed it targets the
+ * one unprefixed set with `allowUnprefixed`. A whole-menu `replaceAll` is refused in that case
+ * whatever the flags say, because deleting every unprefixed row could destroy another site.
+ * Only reads; returns `{ prefix, tables, others }`.
+ * @param {any} client
+ * @param {{ tablePrefix?: string, allowUnprefixed?: boolean, replaceAll?: boolean }} [options]
+ */
+export declare function assertTarget(client: any, { tablePrefix, allowUnprefixed, replaceAll }?: {
+    tablePrefix?: string;
+    allowUnprefixed?: boolean;
+    replaceAll?: boolean;
+}): Promise<{
+    prefix: string;
+    tables: {
+        categories: string;
+        sections: string;
+        products: string;
+    };
+    others: any;
+}>;
 /** What an import would replace: the categories it writes, or the whole menu. */
-export declare function inspect(client: any, menu: any, { replaceAll }?: {
+export declare function inspect(client: any, menu: any, { replaceAll, tablePrefix }?: {
     replaceAll?: boolean | undefined;
+    tablePrefix?: string | undefined;
 }): Promise<any>;
 /**
  * Replaces the menu in one transaction, so readers see the old menu or the new
  * one and a failure changes nothing. By default only the categories in `menu`
  * are replaced (deleting a category cascades to its sections and products);
  * `replaceAll` empties the menu first. Ids are generated here so the rows can
- * be inserted in bulk, a column at a time.
+ * be inserted in bulk, a column at a time. `tablePrefix` is the restaurant's
+ * own table set; the delete is scoped to it, never to another site's tables.
  */
-export declare function replaceMenu(client: any, menu: any, { replaceAll }?: {
+export declare function replaceMenu(client: any, menu: any, { replaceAll, tablePrefix }?: {
     replaceAll?: boolean | undefined;
+    tablePrefix?: string | undefined;
 }): Promise<{
     categories: any;
     sections: any;

package/types/menu/lib/import.d.mts

@@ -8,4 +8,4 @@ export declare function templateHints(menu: any, { projectDir }?: {}): Promise<s
  * @param {import('../../lib/types.mjs').ImportMenuOptions} options
  * @returns {Promise<import('../../lib/types.mjs').ImportResult>}
  */
-export declare function importMenu({ menu, notes, title, dryRun, json, replaceAll, force, databaseUrl, env, projectDir, log: logOption, }?: import('../../lib/types.mjs').ImportMenuOptions): Promise<import('../../lib/types.mjs').ImportResult>;
+export declare function importMenu({ menu, notes, title, dryRun, json, replaceAll, force, tablePrefix, allowUnprefixed, yes, databaseUrl, env, projectDir, log: logOption, }?: import('../../lib/types.mjs').ImportMenuOptions): Promise<import('../../lib/types.mjs').ImportResult>;

package/types/menu/lib/run.d.mts

@@ -4,6 +4,9 @@ export declare const menuFlags: {
     provider: string;
     model: string;
     minWidth: string;
+    tablePrefix: string;
+    allowUnprefixed: string;
+    yes: string;
     replaceAll: string;
     force: string;
     dryRun: string;

package/types/menu/lib/tables.d.mts

@@ -0,0 +1,18 @@
+/**
+ * `tablePrefix` when it is empty or a safe `<name>_` prefix (an ECONFIG error otherwise).
+ * @param {string} [tablePrefix]
+ * @returns {string}
+ */
+export declare function validateTablePrefix(tablePrefix?: string): string;
+/**
+ * The three `public` menu tables for a prefix, e.g.
+ * `{ categories: "public.makibar_menu_categories", sections: "public.makibar_menu_sections", products: "public.makibar_menu_products" }`.
+ * The default (empty prefix) is the unprefixed `public.menu_*` set.
+ * @param {string} [tablePrefix]
+ * @returns {{ categories: string, sections: string, products: string }}
+ */
+export declare function menuTables(tablePrefix?: string): {
+    categories: string;
+    sections: string;
+    products: string;
+};

package/types/menu/raw/config.d.mts

@@ -1,4 +1,5 @@
 declare const _default: {
+    tablePrefix: string;
     url: string;
     currency: string;
     thousands: string;

package/types/menu/raw/import.d.mts

@@ -1,6 +1,7 @@
 /** Every image found, and the numbered ones `only` selects. `config` defaults to config.mjs. */
 export declare function findPages({ urls, only, minWidth, config }?: {
     config?: {
+        tablePrefix: string;
         url: string;
         currency: string;
         thousands: string;
@@ -32,6 +33,7 @@ export declare function listMenuImages(options?: import('../../lib/types.mjs').L
 /** Reads the pages and normalizes them: `{ menu, notes, title }`, ready for importMenu. */
 export declare function fetchImageMenu({ urls, only, provider, model, minWidth, refresh, apiKey, env, projectDir, config, log: logOption }?: {
     config?: {
+        tablePrefix: string;
         url: string;
         currency: string;
         thousands: string;
@@ -55,6 +57,7 @@ export declare function fetchImageMenu({ urls, only, provider, model, minWidth,
     menu: import("../../lib/types.mjs").Menu;
     notes: string[];
     title: string;
+    tablePrefix: string;
 }>;
 /**
  * Reads the menu from pictures with a vision model and imports it. Takes importMenu's options too.

package/types/research/lib/merge.d.mts

@@ -1,9 +1,10 @@
-export declare function buildProfile({ query, google, osm, site, hub, instagram, tripadvisor }: {
+export declare function buildProfile({ query, google, osm, site, hub, instagram, tripadvisor, search }: {
     google: any;
     hub: any;
     instagram: any;
     osm: any;
     query: any;
+    search: any;
     site: any;
     tripadvisor: any;
 }): {
@@ -82,6 +83,8 @@ export declare function buildProfile({ query, google, osm, site, hub, instagram,
             followers: any;
             posts: any;
             blocked: any;
+            partial: any;
+            surface: any;
         } | null;
     };
 };

package/types/research/lib/report.d.mts

@@ -1,4 +1,17 @@
-export declare function renderReport(p: any, { notes, photos }: {
+/**
+ * Splits the fields into what was discovered from a source, what was only echoed
+ * back from the user's own input, and low-confidence guesses, so a summary can
+ * say "N facts, M from your input" instead of counting all of them as found.
+ */
+export declare function fieldSummary(p: any): {
+    discovered: string[];
+    echoed: string[];
+    guessed: string[];
+};
+/** The CLI summary: what came from a source, what was only echoed, what was a low guess. */
+export declare function summaryLines(p: any): string[];
+export declare function renderReport(p: any, { notes, photos, kept }: {
+    kept?: never[] | undefined;
     notes: any;
     photos: any;
 }): string;

package/types/research/lib/search.d.mts

@@ -0,0 +1,58 @@
+/** Unwraps DuckDuckGo's `//duckduckgo.com/l/?uddg=<url>` redirect to the real result URL. */
+export declare function resultUrl(href: any): string | null;
+/** Pulls { url, title, snippet } out of DuckDuckGo's HTML result page (no DOM parser). */
+export declare function parseSearchResults(html: any): {
+    url: string;
+    title: string;
+    snippet: string;
+}[];
+/**
+ * Sorts results into the links the pipeline can follow. `website` is the best
+ * non-directory result whose title/host looks like the restaurant's name; a
+ * result that only matches the place is kept as a weaker candidate.
+ */
+export declare function classifyResults(results: any, { name }?: {
+    name?: string | undefined;
+}): {
+    website: any;
+    instagram: never;
+    tripadvisor: never;
+    facebook: never;
+    tiktok: never;
+    mapsUrl: never;
+    hubs: never[];
+    candidates: {
+        url: any;
+        title: any;
+    }[];
+};
+/**
+ * Runs the search for a restaurant and returns its candidate links. Tries every
+ * endpoint until one returns results; if all answer but none has results, the
+ * empty result is returned so the caller still says "no results" rather than
+ * "failed". Throws only when no endpoint answers.
+ */
+export declare function searchWeb({ name, location }: {
+    location?: string | undefined;
+    name: any;
+}): Promise<{
+    website: any;
+    instagram: never;
+    tripadvisor: never;
+    facebook: never;
+    tiktok: never;
+    mapsUrl: never;
+    hubs: never[];
+    candidates: {
+        url: any;
+        title: any;
+    }[];
+    source: string;
+    url: string;
+    query: string;
+    results: {
+        url: string;
+        title: string;
+        snippet: string;
+    }[];
+}>;