tablefacts 0.1.0

package/src/research/lib/hours.mjs

@@ -0,0 +1,109 @@
+// Opening hours in one shape, whatever the source: week[0..6] (Monday first),
+// each day a list of ["HH:MM", "HH:MM"] slots; a closed day is []. The template
+// shows them as `visit.hoursRows`, consecutive identical days merged.
+
+const pad = (n) => String(n).padStart(2, "0");
+const hm = (h, m = 0) => `${pad(h)}:${pad(m)}`;
+const emptyWeek = () => Array.from({ length: 7 }, () => []);
+const allDay = () => Array.from({ length: 7 }, () => [["00:00", "24:00"]]);
+
+/** Google `regularOpeningHours.periods` (day 0 = Sunday). */
+export function fromGoogle(periods = []) {
+  if (!periods.length) return null;
+  if (periods.length === 1 && !periods[0].close) return { week: allDay() };
+  const week = emptyWeek();
+  for (const p of periods) {
+    if (!p.open || !p.close) continue;
+    week[(p.open.day + 6) % 7].push([hm(p.open.hour, p.open.minute ?? 0), hm(p.close.hour, p.close.minute ?? 0)]);
+  }
+  week.forEach((d) => d.sort());
+  return { week };
+}
+
+const DAY_INDEX = { mo: 0, tu: 1, we: 2, th: 3, fr: 4, sa: 5, su: 6 };
+
+function expandDays(text) {
+  const out = [];
+  for (const part of text.split(",").map((s) => s.trim()).filter(Boolean)) {
+    const [a, b] = part.split("-").map((s) => DAY_INDEX[s.trim().toLowerCase().slice(0, 2)]);
+    if (a === undefined || (part.includes("-") && b === undefined)) return null;
+    if (b === undefined) out.push(a);
+    else for (let d = a; ; d = (d + 1) % 7) { out.push(d); if (d === b) break; }
+  }
+  return out.length ? out : null;
+}
+
+/** OpenStreetMap / schema.org `openingHours` syntax: "Mo-Th 12:00-22:00; Fr,Sa 12:00-00:00; Su off". */
+export function fromOsm(text) {
+  if (!text) return null;
+  if (/^\s*24\/7\s*$/.test(text)) return { week: allDay() };
+  const week = emptyWeek();
+  let any = false;
+  let partial = false;
+  for (const rule of text.split(";").map((s) => s.trim()).filter(Boolean)) {
+    const m = !/\b(PH|SH|week|sunrise|sunset|Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\b|[\[\]()"]/i.test(rule) &&
+      rule.match(/^([A-Za-z,\- ]+?)?\s*((?:\d{1,2}:\d{2}\s*-\s*\d{1,2}:\d{2}\s*,?\s*)+|off|closed)$/i);
+    const days = m ? (m[1] ? expandDays(m[1]) : [0, 1, 2, 3, 4, 5, 6]) : null;
+    if (!m || !days) { partial = true; continue; }
+    const slots = /^(off|closed)$/i.test(m[2])
+      ? []
+      : [...m[2].matchAll(/(\d{1,2}):(\d{2})\s*-\s*(\d{1,2}):(\d{2})/g)].map((x) => [hm(+x[1], +x[2]), hm(+x[3], +x[4])]);
+    for (const d of days) week[d] = slots;
+    any = true;
+  }
+  return any ? { week, partial } : null;
+}
+
+const EN_DAYS = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"];
+
+/** schema.org `openingHoursSpecification` entries. */
+export function fromSpec(specs = []) {
+  const week = emptyWeek();
+  let any = false;
+  for (const s of [specs].flat()) {
+    if (!s || !s.opens || !s.closes) continue;
+    for (const d of [s.dayOfWeek].flat()) {
+      const i = EN_DAYS.indexOf(String(d ?? "").split("/").pop().toLowerCase());
+      if (i < 0) continue;
+      week[i].push([String(s.opens).slice(0, 5), String(s.closes).slice(0, 5)]);
+      any = true;
+    }
+  }
+  week.forEach((d) => d.sort());
+  return any ? { week } : null;
+}
+
+const signature = (slots) => slots.map((s) => s.join("-")).join(",");
+export const weekSignature = (week) => week.map(signature).join("|");
+
+const NAMES = {
+  es: { days: ["lunes", "martes", "miércoles", "jueves", "viernes", "sábado", "domingo"], and: "y", to: "a", closed: "Cerrado", allDay: "24 horas", every: "Todos los días" },
+  en: { days: EN_DAYS, and: "and", to: "to", closed: "Closed", allDay: "24 hours", every: "Every day" },
+};
+const cap = (s) => s[0].toUpperCase() + s.slice(1);
+
+/** Rows for `visit.hoursRows`: { label, value }, matching the template's wording. */
+export function formatRows(week, lang) {
+  const t = NAMES[lang];
+  const runs = [];
+  week.forEach((slots, d) => {
+    const last = runs.at(-1);
+    if (last && signature(last.slots) === signature(slots)) last.days.push(d);
+    else runs.push({ days: [d], slots });
+  });
+  if (runs.every((r) => !r.slots.length)) return [];
+  return runs.map(({ days, slots }) => {
+    const a = t.days[days[0]];
+    const label =
+      days.length === 7 ? t.every
+      : days.length === 1 ? cap(a)
+      : days.length === 2 ? `${cap(a)} ${t.and} ${t.days[days[1]]}`
+      : `${cap(a)} ${t.to} ${t.days[days.at(-1)]}`;
+    const value = !slots.length
+      ? t.closed
+      : signature(slots) === "00:00-24:00"
+        ? t.allDay
+        : slots.map(([o, c]) => `${o} ${t.to} ${c}`).join(", ");
+    return { label, value };
+  });
+}

package/src/research/lib/merge.mjs

@@ -0,0 +1,119 @@
+// Reconciles what each source said into one profile. Every field keeps where it
+// came from, how sure we are, and what the other sources said instead: BRIEF.md
+// warns that Google, TripAdvisor and the restaurant's own site disagree.
+import { digits, fold, km, samePhone, sameText } from "./util.mjs";
+import { formatRows, weekSignature } from "./hours.mjs";
+
+const ES = new Set(["CO", "MX", "ES", "AR", "CL", "PE", "EC", "UY", "VE", "BO", "PY", "CR", "PA", "DO", "GT", "HN", "SV", "NI", "CU", "PR"]);
+const present = (v) => v !== undefined && v !== null && v !== "" && !(Array.isArray(v) && !v.length);
+const handleOf = (v) => String(v ?? "").replace(/^https?:\/\/(www\.)?instagram\.com\//i, "").replace(/^@/, "").split(/[/?#]/)[0].toLowerCase();
+
+/**
+ * First candidate wins (list them most trusted first). Confidence: high when two
+ * sources agree, medium for one, low for a guess (`low: true`).
+ */
+function choose(candidates, same = (a, b) => fold(a) === fold(b)) {
+  const list = candidates.filter((c) => present(c.value));
+  if (!list.length) return null;
+  const first = list[0];
+  const agree = list.filter((c) => same(c.value, first.value));
+  const alternatives = list.filter((c) => !same(c.value, first.value)).map(({ value, source }) => ({ value, source }));
+  const sources = [...new Set(agree.map((c) => c.source))];
+  return {
+    value: first.value,
+    source: sources.join(" + "),
+    confidence: first.low ? "low" : sources.length > 1 ? "high" : "medium",
+    ...(alternatives.length && { alternatives }),
+  };
+}
+
+const cleanUrl = (u) => {
+  try {
+    const x = new URL(u);
+    [...x.searchParams.keys()].filter((k) => /^utm_|^fbclid|^gclid/.test(k)).forEach((k) => x.searchParams.delete(k));
+    return x.href.replace(/\/$/, "");
+  } catch { return u; }
+};
+
+export function buildProfile({ query, google, osm, site, hub, instagram, tripadvisor }) {
+  const g = google ?? {};
+  const o = osm ?? {};
+  const ld = site?.jsonld ?? null;
+  const ta = tripadvisor?.jsonld ?? null;
+  const warnings = [];
+  const ok = (v) => (v ? v : undefined);
+  const hubLinks = hub?.links ?? {};
+  const links = (k) => [...(site?.links?.[k] ?? []), ...(hubLinks[k] ?? [])];
+
+  if (g.status && g.status !== "OPERATIONAL") warnings.push(`Google lists this place as ${g.status}.`);
+  if (g.coords && o.coords && km(g.coords, o.coords) > 0.5) warnings.push("Google and OpenStreetMap place it more than 500 m apart: check they are the same restaurant.");
+  if (!google && !osm) warnings.push("No Google or OpenStreetMap match: facts rely on the website and social pages only.");
+
+  const coordSame = (a, b) => km(a, b) < 0.15;
+  const phoneSame = samePhone;
+  const igLinks = [...(site?.links?.instagram ?? []), ...(hubLinks.instagram ?? [])];
+
+  const fields = {
+    name: choose([{ value: g.name, source: "google" }, { value: ld?.name, source: "website" }, { value: ta?.name, source: "tripadvisor" }, { value: o.name, source: "osm" }, { value: site?.meta.siteName, source: "website" }], sameText),
+    street: choose([{ value: g.street, source: "google" }, { value: ld?.address.street, source: "website" }, { value: ta?.address.street, source: "tripadvisor" }, { value: o.street, source: "osm" }], sameText),
+    locality: choose([{ value: g.locality, source: "google" }, { value: ld?.address.locality, source: "website" }, { value: o.locality, source: "osm" }], sameText),
+    region: choose([{ value: g.region, source: "google" }, { value: ld?.address.region, source: "website" }, { value: o.region, source: "osm" }], sameText),
+    country: choose([{ value: query.country?.toUpperCase(), source: "you" }, { value: g.country, source: "google" }, { value: o.country, source: "osm" }, { value: ld?.address.country.length === 2 ? ld.address.country.toUpperCase() : "", source: "website" }]),
+    coordinates: choose([{ value: g.coords, source: "google" }, { value: o.coords, source: "osm" }, { value: ld?.geo, source: "website" }], coordSame),
+    phone: choose([{ value: g.phone, source: "google" }, { value: ok(links("tel")[0]), source: "website" }, { value: ld?.telephone, source: "website" }, { value: ta?.telephone, source: "tripadvisor" }, { value: instagram?.phones?.[0], source: "instagram" }, { value: o.phone, source: "osm" }], phoneSame),
+    email: choose([{ value: ld?.email, source: "website" }, { value: links("mail").find((m) => !/sentry|wixpress|example|domain\./i.test(m)), source: "website" }, { value: o.email, source: "osm" }]),
+    instagram: choose([{ value: query.instagram && handleOf(query.instagram), source: "you" }, ...igLinks.map((h) => ({ value: h, source: "website" })), ...(ld?.sameAs ?? []).filter((u) => /instagram\.com/.test(u)).map((u) => ({ value: handleOf(u), source: "website" })), { value: o.instagram && handleOf(o.instagram), source: "osm" }]),
+    facebook: choose([{ value: links("facebook")[0], source: "website" }, { value: o.facebook, source: "osm" }]),
+    tiktok: choose([{ value: links("tiktok")[0], source: "website" }]),
+    tripadvisor: choose([{ value: query.tripadvisor, source: "you" }, { value: links("tripadvisor")[0], source: "website" }, { value: (ld?.sameAs ?? []).find((u) => /tripadvisor\./.test(u)), source: "website" }]),
+    website: choose([{ value: query.website && cleanUrl(query.website), source: "you" }, { value: g.website && cleanUrl(g.website), source: "google" }, { value: o.website && cleanUrl(o.website), source: "osm" }]),
+    reserveUrl: choose([...links("reserve").map((u) => ({ value: u, source: "website" }))]),
+    priceRange: choose([{ value: g.priceRange, source: "google" }, { value: ld?.priceRange, source: "website" }, { value: ta?.priceRange, source: "tripadvisor" }]),
+    mapsUrl: choose([{ value: g.mapsUrl, source: "google" }, { value: links("maps")[0], source: "website" }]),
+    descriptor: choose([{ value: g.descriptor, source: "google" }]),
+  };
+
+  // WhatsApp: an explicit link wins; otherwise the phone is only a guess.
+  const wa = [...links("whatsapp"), o.whatsapp].map(digits).find((d) => d.length >= 7);
+  const phoneDisplay = (n) => [g.phone, ...(links("tel")), ld?.telephone].find((p) => p && p.trim().startsWith("+") && samePhone(p, n)) ?? `+${digits(n)}`;
+  if (wa) fields.whatsapp = { value: wa, display: phoneDisplay(wa), source: site?.links?.whatsapp?.length ? "website" : hubLinks.whatsapp?.length ? "link-in-bio" : "osm", confidence: "medium" };
+  else if (fields.phone) fields.whatsapp = { value: digits(fields.phone.value), display: fields.phone.value, source: fields.phone.source, confidence: "low", note: "Guess: the phone number. Confirm that it takes WhatsApp." };
+
+  const cuisines = [...new Set([...(g.cuisines ?? []), ...(ld?.cuisines ?? []), ...(ta?.cuisines ?? []), ...(o.cuisines ?? [])].map((c) => c.trim()).filter(Boolean))];
+  if (cuisines.length) {
+    const from = [g.cuisines?.length && "google", ld?.cuisines?.length && "website", ta?.cuisines?.length && "tripadvisor", o.cuisines?.length && "osm"].filter(Boolean);
+    fields.cuisines = { value: cuisines, source: from.join(" + "), confidence: from.length > 1 ? "high" : "medium" };
+  }
+
+  const lang = (site?.lang ?? "").slice(0, 2);
+  const country = fields.country?.value;
+  const menuLocale = ["es", "en"].includes(lang) ? lang : ES.has(country) ? "es" : country ? "en" : "";
+  if (menuLocale) fields.menuLocale = { value: menuLocale, source: ["es", "en"].includes(lang) ? "website language" : "country", confidence: "low", note: "Guess. The language the dish names are written in decides this." };
+
+  // Hours: the restaurant's own markup first, then Google, then OSM.
+  const hourSources = [
+    { source: "website", week: ld?.hours?.week },
+    { source: "tripadvisor", week: ta?.hours?.week },
+    { source: "google", week: g.hours?.week },
+    { source: "osm", week: o.hours?.week, partial: o.hours?.partial },
+  ].filter((h) => h.week);
+  const hours = hourSources.length
+    ? {
+        source: hourSources[0].source,
+        week: hourSources[0].week,
+        rows: { es: formatRows(hourSources[0].week, "es"), en: formatRows(hourSources[0].week, "en") },
+        confidence: hourSources.filter((h) => weekSignature(h.week) === weekSignature(hourSources[0].week)).length > 1 ? "high" : "medium",
+        conflicts: hourSources.filter((h) => weekSignature(h.week) !== weekSignature(hourSources[0].week)).map((h) => ({ source: h.source, rows: formatRows(h.week, "en") })),
+      }
+    : null;
+
+  return {
+    query, generatedAt: new Date().toISOString(), warnings, fields, hours,
+    textHours: [...(site?.hoursText ?? [])],
+    links: { menu: links("menu"), delivery: links("delivery"), reserve: links("reserve"), waze: links("waze"), hubs: [...new Set([...(site?.links?.hubs ?? []), ...(instagram?.links ?? []).filter((l) => /linktr|beacons|bio\.link|lnk\.bio|taplink/.test(l))])] },
+    ratings: [g.rating && { source: "google", value: g.rating, count: g.ratingCount }, ld?.rating && { source: "website", ...ld.rating }, ta?.rating && { source: "tripadvisor", ...ta.rating }].filter(Boolean),
+    images: { logos: [...(site?.logos ?? []), ...(hub?.logos ?? [])].filter((l) => l.url), site: site?.images ?? [], hub: hub?.images ?? [], googlePhotos: g.photos?.length ?? 0, instagramImage: instagram?.image ?? "", themeColor: site?.meta.themeColor ?? "" },
+    copySources: { googleSummary: g.summary ?? "", siteDescription: site?.meta.description ?? "", instagramBio: instagram?.bio ?? "", tripadvisor: tripadvisor?.description ?? "", headings: site?.headings ?? [], paragraphs: site?.paragraphs ?? [] },
+    social: { instagram: instagram ? { handle: instagram.handle, followers: instagram.followers, posts: instagram.posts, blocked: instagram.blocked } : null },
+  };
+}

package/src/research/lib/osm.mjs

@@ -0,0 +1,49 @@
+// OpenStreetMap through Nominatim: no key, so it is the fallback when Google is
+// not configured and a second opinion when it is. Policy: identify yourself and
+// stay under one request per second (this makes one).
+import { fetchText, sameText } from "./util.mjs";
+import { fromOsm } from "./hours.mjs";
+
+function normalize(p) {
+  const a = p.address ?? {};
+  const x = p.extratags ?? {};
+  const tag = (...keys) => keys.map((k) => x[k]).find(Boolean) ?? "";
+  return {
+    source: "osm",
+    name: p.name ?? p.namedetails?.name ?? "",
+    street: [a.road, a.house_number].filter(Boolean).join(" "),
+    locality: (a.city ?? a.town ?? a.village ?? a.municipality ?? "").replace(/^Perímetro Urbano\s+/i, ""),
+    region: a.state ?? "",
+    country: (a.country_code ?? "").toUpperCase(),
+    postcode: a.postcode ?? "",
+    coords: { lat: Number(p.lat), lng: Number(p.lon) },
+    phone: tag("phone", "contact:phone"),
+    whatsapp: tag("contact:whatsapp"),
+    email: tag("email", "contact:email"),
+    website: tag("website", "contact:website"),
+    instagram: tag("contact:instagram"),
+    facebook: tag("contact:facebook"),
+    cuisines: (x.cuisine ?? "").split(";").map((c) => c.trim().replace(/_/g, " ")).filter(Boolean).map((c) => c[0].toUpperCase() + c.slice(1)),
+    hours: fromOsm(x.opening_hours),
+    hoursRaw: x.opening_hours ?? "",
+    osmUrl: p.osm_type && p.osm_id ? `https://www.openstreetmap.org/${p.osm_type}/${p.osm_id}` : "",
+  };
+}
+
+export async function searchOsm({ name, location, country }) {
+  const params = new URLSearchParams({
+    q: `${name}, ${location}`.replace(/,\s*$/, ""),
+    format: "jsonv2", addressdetails: "1", extratags: "1", namedetails: "1", limit: "5",
+    ...(country && { countrycodes: country.toLowerCase() }),
+  });
+  const r = await fetchText(`https://nominatim.openstreetmap.org/search?${params}`, {
+    headers: { "user-agent": "cannario-research/1.0 (restaurant site template)", accept: "application/json" },
+  });
+  if (!r.ok) throw new Error(`Nominatim ${r.status}`);
+  const list = JSON.parse(r.text);
+  const hit = list.find((p) => sameText(p.name ?? p.namedetails?.name ?? "", name));
+  return {
+    place: hit ? normalize(hit) : null,
+    candidates: list.map((p) => ({ name: p.name ?? "", address: p.display_name })),
+  };
+}

package/src/research/lib/report.mjs

@@ -0,0 +1,118 @@
+// Turns a profile into what a person (or an agent) acts on: a report that mirrors
+// BRIEF.md's table, and the answers file `npm run setup` reads from stdin.
+const val = (f) => {
+  if (!f) return "";
+  const v = f.value;
+  if (Array.isArray(v)) return v.join(", ");
+  if (v && typeof v === "object") return `${v.lat}, ${v.lng}`;
+  return String(v);
+};
+
+const ROWS = [
+  ["Legal and display name", "name", "`site.name`"],
+  ["Street address", "street", "`site.street`"],
+  ["City", "locality", "`site.locality`"],
+  ["Region", "region", "`site.region`"],
+  ["Country (ISO)", "country", "`site.country`"],
+  ["Map point", "coordinates", "`site.coordinates`"],
+  ["WhatsApp number", "whatsapp", "`site.whatsapp`, `whatsappDisplay`"],
+  ["Landline or reservations number", "phone", "`site.phone` (hide it if it is the WhatsApp number)"],
+  ["Email", "email", "`site.email`"],
+  ["Instagram", "instagram", "`site.instagram`, `instagramHandle`"],
+  ["Reservations platform", "reserveUrl", "`site.reserveUrl` (WhatsApp link if none)"],
+  ["Cuisine(s)", "cuisines", "`site.cuisines`"],
+  ["Price range", "priceRange", "BRIEF only"],
+  ["Menu language", "menuLocale", "`MENU_LOCALE`"],
+  ["Current website", "website", "reference (the new `site.url` is the new domain)"],
+  ["TripAdvisor", "tripadvisor", "reference"],
+  ["Facebook", "facebook", "reference"],
+  ["TikTok", "tiktok", "reference"],
+  ["Google Maps", "mapsUrl", "reference"],
+  ["Descriptor (tagline idea)", "descriptor", "`brand.tagline`, both languages"],
+];
+
+const cell = (s) => String(s).replace(/\|/g, "\\|");
+
+export function renderReport(p, { notes, photos }) {
+  const out = [];
+  const q = p.query;
+  out.push(`# Research: ${q.name}${q.location ? `, ${q.location}` : ""}`, "", `Generated ${p.generatedAt}. Everything here is **unconfirmed**: check it with the client and copy the answers into \`BRIEF.md\`. Sources disagree often, and the confidence column says how many agreed.`, "");
+  if (p.warnings.length) out.push("## Warnings", "", ...p.warnings.map((w) => `- ${w}`), "");
+  if (notes.length) out.push("## What each source did", "", ...notes.map((n) => `- ${n}`), "");
+
+  out.push("## Facts", "", "| Item | Value | Source | Confidence | Goes in |", "| --- | --- | --- | --- | --- |");
+  for (const [label, key, goes] of ROWS) {
+    const f = p.fields[key];
+    out.push(`| ${label} | ${f ? cell(val(f)) : "_not found_"} | ${f?.source ?? ""} | ${f?.confidence ?? ""} | ${goes} |`);
+  }
+  out.push("");
+
+  const conflicts = Object.entries(p.fields).filter(([, f]) => f?.alternatives?.length);
+  if (conflicts.length) {
+    out.push("## Sources disagree", "");
+    for (const [key, f] of conflicts) out.push(`- **${key}**: using \`${val(f)}\` (${f.source}); others say ${f.alternatives.map((a) => `\`${val({ value: a.value })}\` (${a.source})`).join(", ")}`);
+    out.push("");
+  }
+  for (const key of ["whatsapp", "menuLocale"]) if (p.fields[key]?.note) out.push(`> ${key}: ${p.fields[key].note}`, "");
+
+  out.push("## Opening hours", "");
+  if (p.hours) {
+    out.push(`From ${p.hours.source} (${p.hours.confidence}). Paste into \`visit.hoursRows\`:`, "");
+    for (const lang of ["es", "en"]) out.push(`\`${lang}\``, "```ts", "hoursRows: [", ...p.hours.rows[lang].map((r) => `  { label: ${JSON.stringify(r.label)}, value: ${JSON.stringify(r.value)} },`), "],", "```", "");
+    for (const c of p.hours.conflicts) out.push(`- ${c.source} disagrees: ${c.rows.map((r) => `${r.label} ${r.value}`).join("; ")}`);
+  } else out.push("No structured hours found.");
+  if (p.textHours.length) out.push("", "Hours text found on the website (verify, then use):", ...p.textHours.map((t) => `- ${t}`));
+  out.push("");
+
+  out.push("## Links worth following", "");
+  const list = (label, arr) => arr.length && out.push(`- **${label}:** ${arr.map((u) => u).join(", ")}`);
+  list("Menu", p.links.menu);
+  list("Delivery", p.links.delivery);
+  list("Link-in-bio", p.links.hubs);
+  list("Waze", p.links.waze);
+  if (p.links.menu.some((u) => /cluvi/i.test(u))) out.push("- The menu is on Cluvi: use `tablefacts menu cluvi` (see `src/menu/README.md` in the tablefacts package).");
+  else if (p.links.menu.some((u) => /\.pdf/i.test(u))) out.push("- The menu is a PDF: `tablefacts menu raw` reads it.");
+  out.push("");
+
+  if (p.ratings.length) out.push("## Ratings (context only)", "", ...p.ratings.map((r) => `- ${r.source}: ${r.value}${r.count ? ` (${r.count} reviews)` : ""}`), "");
+  if (p.social.instagram && !p.social.instagram.blocked) out.push(`Instagram @${p.social.instagram.handle}: ${p.social.instagram.followers} followers, ${p.social.instagram.posts} posts.`, "");
+
+  out.push("## Images", "");
+  out.push(`- Website images found: ${p.images.site.length}; link-in-bio: ${p.images.hub.length}; Google photos available: ${p.images.googlePhotos}.`);
+  if (p.images.logos[0]) out.push(`- Logo candidates: ${p.images.logos.slice(0, 4).map((l) => l.url).join(", ")}`);
+  if (p.images.themeColor) out.push(`- Site theme colour: \`${p.images.themeColor}\` (a hint for \`tokens.css\`).`);
+  if (photos.length) out.push(`- Downloaded to \`photos/\` (${photos.length}). **They are reference, not assets**: the restaurant or the photographer owns them. Ask the client for originals, or get written permission, before shipping any.`);
+  out.push("");
+
+  out.push("## Material for the copy", "", "Facts and tone only. Rewrite it in the template's voice in both languages; do not paste it.", "");
+  const c = p.copySources;
+  for (const [label, text] of [["Google summary", c.googleSummary], ["Site description", c.siteDescription], ["Instagram bio", c.instagramBio], ["TripAdvisor", c.tripadvisor]]) if (text) out.push(`- **${label}:** ${text}`);
+  if (c.headings.length) out.push(`- **Site headings:** ${c.headings.slice(0, 12).join(" / ")}`);
+  for (const t of c.paragraphs.slice(0, 6)) out.push(`  - ${t}`);
+  out.push("");
+
+  const missing = ROWS.filter(([, key]) => !p.fields[key] && ["name", "street", "coordinates", "whatsapp", "instagram", "reserveUrl", "cuisines"].includes(key)).map(([l]) => l);
+  out.push("## Ask the client", "", ...[...missing, "Opening hours incl. holidays", "Logo as SVG and original photos", "The story, signature dishes and events", "Production domain"].filter((v, i, a) => a.indexOf(v) === i && (v !== "Opening hours incl. holidays" || true)).map((m) => `- ${m}`), "");
+  out.push("## Next", "", "```bash", `npm run setup < .tablefacts/research/${q.slug}/setup-answers.txt`, "git diff   # review before keeping it", "```", "", "Blank lines in that file keep the template's current value, so anything not found stays a placeholder.", "");
+  return out.join("\n");
+}
+
+/** One line per prompt of `data/scripts/setup.mjs`, in its order. Blank keeps the current value. */
+export function setupAnswers(p) {
+  const f = p.fields;
+  const ig = f.instagram?.value;
+  return [
+    val(f.name),
+    "", // production URL: the new domain, not the current website
+    f.reserveUrl?.value ?? "",
+    f.whatsapp?.display ?? "",
+    ig ? `@${ig}` : "",
+    val(f.street),
+    val(f.locality),
+    val(f.region),
+    val(f.country),
+    f.coordinates?.value?.lat ?? "",
+    f.coordinates?.value?.lng ?? "",
+    val(f.cuisines),
+  ].join("\n") + "\n";
+}

package/src/research/lib/social.mjs

@@ -0,0 +1,49 @@
+// 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 { 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)" };
+  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) ?? [];
+  return {
+    handle, url,
+    displayName: 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"),
+  };
+}
+
+/** TripAdvisor: schema.org JSON-LD when the page loads; DataDome often blocks it. */
+export async function readTripadvisor(url, { browser } = {}) {
+  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) };
+}
+
+/** A link-in-bio hub (Linktree, Beacons, bio.link): its links, classified like a website's. */
+export async function readHub(url, { browser } = {}) {
+  const { page, blocked } = await readPage(url, { renderJs: false, browser });
+  if (!page) return { url, blocked };
+  return { url: page.url, title: page.title, meta: page.meta, links: page.links, anchors: page.anchors.filter((a) => a.text).slice(0, 30), logos: page.logos, images: page.images.slice(0, 10) };
+}

package/src/research/lib/util.mjs

@@ -0,0 +1,104 @@
+// Small helpers shared by the research sources: HTTP, name matching.
+import { fold, slugify as slug } from "../../lib/text.mjs";
+
+export { fold };
+
+export const BROWSER_UA =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0 Safari/537.36 cannario-research";
+
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** 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);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await fn(items[i], i);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(size, items.length) }, worker));
+  return results;
+}
+
+export const MAX_BODY_BYTES = 2 * 1024 * 1024;
+const BINARY_TYPE = /^\s*(image|video|audio|font)\/|application\/(pdf|zip|gzip|octet-stream|vnd\.[\w.+-]*(?:excel|powerpoint|ms-)[\w.+-]*)/i;
+
+async function readCapped(res, cap) {
+  const declared = Number(res.headers.get("content-length"));
+  const reader = res.body?.getReader?.();
+  if (!reader) {
+    // No stream (a minimal Response-like): read it whole, then cut.
+    const text = await res.text();
+    return text.length > cap ? { text: text.slice(0, cap), truncated: true } : { text, truncated: false };
+  }
+  const chunks = [];
+  let size = 0;
+  let truncated = Number.isFinite(declared) && declared > cap;
+  while (size < cap) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    size += value.length;
+  }
+  if (size >= cap) {
+    truncated = true;
+    await reader.cancel().catch(() => {});
+  }
+  const buf = Buffer.concat(chunks.map((c) => Buffer.from(c.buffer, c.byteOffset, c.byteLength))).subarray(0, cap);
+  return { text: buf.toString("utf8"), truncated };
+}
+
+/**
+ * GETs a URL as text. The body is capped at 2 MB (`truncated: true` when it was cut, never an error) and a
+ * clearly binary content-type (image, pdf, zip...) is not read at all (`skipped: true`, empty text).
+ */
+export async function fetchText(url, { headers = {}, timeout = 15000, maxBytes = MAX_BODY_BYTES } = {}) {
+  const res = await fetch(url, {
+    headers: { "user-agent": BROWSER_UA, "accept-language": "es,en;q=0.8", accept: "text/html,application/json,*/*", ...headers },
+    redirect: "follow",
+    signal: AbortSignal.timeout(timeout),
+  });
+  const type = res.headers.get("content-type") ?? "";
+  const head = { ok: res.ok, status: res.status, url: res.url, type };
+  if (BINARY_TYPE.test(type)) {
+    await res.body?.cancel?.().catch?.(() => {});
+    return { ...head, text: "", skipped: true };
+  }
+  const { text, truncated } = await readCapped(res, maxBytes);
+  return truncated ? { ...head, text, truncated: true } : { ...head, text };
+}
+
+const STOP = new Set(["restaurante", "restaurant", "bar", "the", "el", "la", "los", "las", "de", "del", "y", "and", "cafe", "gastro", "grill", "bistro", "calle", "carrera", "cra", "cl", "av", "avenida"]);
+export const tokens = (s) => fold(s).split(/[^a-z0-9]+/).filter((t) => t && !STOP.has(t));
+
+/** Loose text match: at least 60% of the shorter side's words appear in the other. */
+export function sameText(a, b) {
+  const A = new Set(tokens(a));
+  const B = new Set(tokens(b));
+  if (!A.size || !B.size) return fold(a).trim() === fold(b).trim();
+  let hit = 0;
+  for (const t of A) if (B.has(t)) hit++;
+  return hit / Math.min(A.size, B.size) >= 0.6;
+}
+
+export const slugify = (s) => slug(s) || "restaurant";
+
+export const digits = (s) => String(s ?? "").replace(/\D/g, "");
+
+/** Same phone number written differently (spaces, +country, leading 0). */
+export const samePhone = (a, b) => {
+  const x = digits(a);
+  const y = digits(b);
+  return x.length >= 7 && y.length >= 7 && x.slice(-9) === y.slice(-9);
+};
+
+/** Distance in km between two { lat, lng } points. */
+export function km(a, b) {
+  const rad = (d) => (d * Math.PI) / 180;
+  const dLat = rad(b.lat - a.lat);
+  const dLng = rad(b.lng - a.lng);
+  const h = Math.sin(dLat / 2) ** 2 + Math.cos(rad(a.lat)) * Math.cos(rad(b.lat)) * Math.sin(dLng / 2) ** 2;
+  return 12742 * Math.asin(Math.sqrt(h));
+}