dh-remixer-sdk 0.0.45-bbd866f → 0.0.45-ca64e2c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dh-remixer-sdk",
-  "version": "0.0.45-bbd866f",
+  "version": "0.0.45-ca64e2c",
   "type": "module",
   "files": [
     "templates",
@@ -29,6 +29,10 @@
     "eslint": "9.0.0",
     "eslint-plugin-import": "2.32.0",
     "eslint-plugin-n": "17.24.0",
-    "globals": "17.4.0"
+    "globals": "17.4.0",
+    "jsdom": "26.1.0",
+    "react": "19.2.0",
+    "react-dom": "19.2.0",
+    "react-helmet-async": "3.0.0"
   }
 }

package/scripts/ssg-helmet/build-sitemap-xml.mjs

@@ -1,3 +1,5 @@
+import { canonicalUrl, normalizeRoutePath } from "./seo-settings.mjs";
+
 const PRIORITY_HOME = 1.0;
 const PRIORITY_NORMAL = 0.8;
 const PRIORITY_TEMPLATED = 0.6;
@@ -6,18 +8,12 @@ const CHANGEFREQ_HOME = "daily";
 const CHANGEFREQ_NORMAL = "weekly";
 const CHANGEFREQ_TEMPLATED = "weekly";
 
-const ensureTrailingSlash = (p) => {
-  const [base, suffix] = p.split(/([?#].*)/); // keep query/hash intact
-  const normalized = base.endsWith("/") ? base : base + "/";
-  return suffix ? normalized + suffix : normalized;
-};
-
 export function buildSitemapXml(origin, routes) {
   if (!/^https?:\/\//i.test(origin)) origin = "https://" + origin;
   const cleanOrigin = origin.replace(/\/+$/, "");
   const today = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
 
-  const abs = (route) => `${cleanOrigin}${route === "/" ? "/" : route}`;
+  const loc = (route) => canonicalUrl(cleanOrigin, route);
   const esc = (s) =>
     String(s)
       .replace(/&/g, "&")
@@ -29,28 +25,28 @@ export function buildSitemapXml(origin, routes) {
   const entries = [];
   for (const item of routes) {
     if (typeof item === "string") {
-      entries.push({ path: item, kind: item === "/" ? "home" : "normal" });
+      entries.push({ url: loc(item), kind: normalizeRoutePath(item) === "/" ? "home" : "normal" });
     } else if (item && typeof item === "object") {
       for (const concrete of Object.values(item)) {
         if (!Array.isArray(concrete)) continue;
-        for (const r of concrete) entries.push({ path: r, kind: "templated" });
+        for (const r of concrete) entries.push({ url: loc(r), kind: "templated" });
       }
     }
   }
 
   const rank = { home: 3, normal: 2, templated: 1 };
-  const byPath = new Map();
+  const byUrl = new Map();
   for (const e of entries) {
-    const prev = byPath.get(e.path);
-    if (!prev || rank[e.kind] > rank[prev.kind]) byPath.set(e.path, e);
+    const prev = byUrl.get(e.url);
+    if (!prev || rank[e.kind] > rank[prev.kind]) byUrl.set(e.url, e);
   }
 
-  const ordered = Array.from(byPath.values()).sort((a, b) => {
+  const ordered = Array.from(byUrl.values()).sort((a, b) => {
     const rk = rank[b.kind] - rank[a.kind];
-    return rk || a.path.localeCompare(b.path);
+    return rk || a.url.localeCompare(b.url);
   });
 
-  const node = ({ path, kind }) => {
+  const node = ({ url, kind }) => {
     const priority =
       kind === "home"
         ? PRIORITY_HOME
@@ -66,7 +62,7 @@ export function buildSitemapXml(origin, routes) {
           : CHANGEFREQ_NORMAL;
 
     return `  <url>
-    <loc>${esc(abs(ensureTrailingSlash(path)))}</loc>
+    <loc>${esc(url)}</loc>
     <lastmod>${today}</lastmod>
     <changefreq>${changefreq}</changefreq>
     <priority>${priority.toFixed(1)}</priority>

package/scripts/ssg-helmet/build-sitemap-xml.test.mjs

@@ -0,0 +1,22 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { buildSitemapXml } from "./build-sitemap-xml.mjs";
+
+const ORIGIN = "https://flowremixer.dreamhosters.com";
+const locs = (xml) => [...xml.matchAll(/<loc>([^<]*)<\/loc>/g)].map(([, loc]) => loc);
+
+test("the root is listed with a slash and every other page without one", () => {
+  assert.deepEqual(locs(buildSitemapXml(ORIGIN, ["/", "/about", "/shop/", "/contact?ref=nav#form"])), [
+    `${ORIGIN}/`,
+    `${ORIGIN}/about`,
+    `${ORIGIN}/contact`,
+    `${ORIGIN}/shop`,
+  ]);
+});
+
+test("templated pages use the same canonical form and a page listed twice appears once", () => {
+  const xml = buildSitemapXml("flowremixer.dreamhosters.com/", ["/", "/about/", "/about", { "/product/:id": ["/product/nox-1/", "/product/nox-2"] }]);
+
+  assert.deepEqual(locs(xml), [`${ORIGIN}/`, `${ORIGIN}/about`, `${ORIGIN}/product/nox-1`, `${ORIGIN}/product/nox-2`]);
+  assert.match(xml, new RegExp(`<loc>${ORIGIN}/product/nox-1</loc>\\s*<lastmod>[^<]+</lastmod>\\s*<changefreq>weekly</changefreq>\\s*<priority>0.6</priority>`));
+});

package/scripts/ssg-helmet/business-hours.mjs

@@ -0,0 +1,65 @@
+const DAY_CODES = ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"];
+const DAY_NAMES = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+const DAY_ABBREVIATIONS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+const OPENING_TIME_RE = /^(?:[01]\d|2[0-3]):[0-5]\d$/;
+const CLOSING_TIME_RE = /^(?:(?:[01]\d|2[0-3]):[0-5]\d|24:00)$/;
+
+function entryProblem(entry) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) return "is not a days/opens/closes entry";
+  if (!Array.isArray(entry.days) || entry.days.length === 0) return "has no days";
+  const unknown = entry.days.find((day) => !DAY_CODES.includes(day));
+  if (unknown !== undefined) return `has an unknown day code ${JSON.stringify(unknown)}`;
+  if (typeof entry.opens !== "string" || !OPENING_TIME_RE.test(entry.opens)) {
+    return `has a bad opening time ${JSON.stringify(entry.opens ?? null)}`;
+  }
+  if (typeof entry.closes !== "string" || !CLOSING_TIME_RE.test(entry.closes)) {
+    return `has a bad closing time ${JSON.stringify(entry.closes ?? null)}`;
+  }
+  if (entry.opens === entry.closes) return "opens and closes at the same time";
+  return null;
+}
+
+export function businessHours(hours) {
+  const valid = [];
+  const invalid = [];
+  (Array.isArray(hours) ? hours : []).forEach((entry, index) => {
+    const problem = entryProblem(entry);
+    if (problem) invalid.push({ index, problem });
+    else valid.push(entry);
+  });
+  return { valid, invalid };
+}
+
+const dayIndexes = (days) =>
+  DAY_CODES.map((code, index) => (days.includes(code) ? index : -1)).filter((index) => index >= 0);
+
+const schemaClosingTime = ({ opens, closes }) => {
+  if (closes !== "24:00") return closes;
+  return opens === "00:00" ? "23:59" : "00:00";
+};
+
+export const openingHoursSpecification = (entries) =>
+  entries.map((entry) => ({
+    "@type": "OpeningHoursSpecification",
+    dayOfWeek: dayIndexes(entry.days).map((index) => DAY_NAMES[index]),
+    opens: entry.opens,
+    closes: schemaClosingTime(entry),
+  }));
+
+function dayRanges(days) {
+  const ranges = [];
+  for (const index of dayIndexes(days)) {
+    const last = ranges.at(-1);
+    if (last && index === last.end + 1) last.end = index;
+    else ranges.push({ start: index, end: index });
+  }
+  return ranges
+    .map(({ start, end }) => {
+      if (start === end) return DAY_ABBREVIATIONS[start];
+      const separator = end === start + 1 ? ", " : "–";
+      return `${DAY_ABBREVIATIONS[start]}${separator}${DAY_ABBREVIATIONS[end]}`;
+    })
+    .join(", ");
+}
+
+export const hoursLine = (entry) => `${dayRanges(entry.days)} ${entry.opens}–${entry.closes}`;

package/scripts/ssg-helmet/business-hours.test.mjs

@@ -0,0 +1,50 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { businessHours, hoursLine, openingHoursSpecification } from "./business-hours.mjs";
+
+const HOURS = [
+  { days: ["Mo", "Tu", "We", "Th"], opens: "16:00", closes: "24:00" },
+  { days: ["Sa", "Fr"], opens: "16:00", closes: "02:00" },
+  { days: ["Su"], opens: "00:00", closes: "24:00" },
+];
+
+test("structured hours become opening hours specifications as stored", () => {
+  assert.deepEqual(openingHoursSpecification(businessHours(HOURS).valid), [
+    { "@type": "OpeningHoursSpecification", dayOfWeek: ["Monday", "Tuesday", "Wednesday", "Thursday"], opens: "16:00", closes: "00:00" },
+    { "@type": "OpeningHoursSpecification", dayOfWeek: ["Friday", "Saturday"], opens: "16:00", closes: "02:00" },
+    { "@type": "OpeningHoursSpecification", dayOfWeek: ["Sunday"], opens: "00:00", closes: "23:59" },
+  ]);
+});
+
+test("structurally invalid entries are set aside with the reason", () => {
+  const { valid, invalid } = businessHours([
+    HOURS[0],
+    { days: ["Mx"], opens: "09:00", closes: "17:00" },
+    { days: ["Mo"], opens: "9am", closes: "17:00" },
+    { days: ["Mo"], opens: "09:00", closes: "25:00" },
+    { days: [], opens: "09:00", closes: "17:00" },
+    { days: ["Mo"], opens: "09:00", closes: "09:00" },
+    "Mon–Fri 9am–5pm",
+  ]);
+
+  assert.deepEqual(valid, [HOURS[0]]);
+  assert.deepEqual(invalid, [
+    { index: 1, problem: 'has an unknown day code "Mx"' },
+    { index: 2, problem: 'has a bad opening time "9am"' },
+    { index: 3, problem: 'has a bad closing time "25:00"' },
+    { index: 4, problem: "has no days" },
+    { index: 5, problem: "opens and closes at the same time" },
+    { index: 6, problem: "is not a days/opens/closes entry" },
+  ]);
+});
+
+test("a missing or empty hours list is no hours", () => {
+  assert.deepEqual(businessHours(undefined), { valid: [], invalid: [] });
+  assert.deepEqual(businessHours([]), { valid: [], invalid: [] });
+});
+
+test("hours read as English day abbreviations for llms.txt", () => {
+  assert.equal(hoursLine(HOURS[0]), "Mon–Thu 16:00–24:00");
+  assert.equal(hoursLine(HOURS[1]), "Fri, Sat 16:00–02:00");
+  assert.equal(hoursLine({ days: ["Mo", "We", "Fr", "Sa", "Su"], opens: "09:00", closes: "17:00" }), "Mon, Wed, Fri–Sun 09:00–17:00");
+});

package/scripts/ssg-helmet/business-ld-json.mjs

@@ -0,0 +1,138 @@
+import { textValue } from "./seo-settings.mjs";
+import { businessHours, openingHoursSpecification } from "./business-hours.mjs";
+import { locatedAddress } from "./geocoded-address.mjs";
+
+const SCHEMA_CONTEXT = "https://schema.org";
+const PRICE_RANGES = new Set(["$", "$$", "$$$"]);
+const BUSINESS_SCHEMA_TYPES = {
+  restaurant: "Restaurant",
+  cafe: "CafeOrCoffeeShop",
+  bar: "BarOrPub",
+  bakery: "Bakery",
+  shop: "Store",
+  "online store": "OnlineStore",
+  florist: "Florist",
+  "salon or spa": "BeautySalon",
+  "fitness studio": "ExerciseGym",
+  "health clinic": "MedicalClinic",
+  "repair shop": "LocalBusiness",
+  "home services": "HomeAndConstructionBusiness",
+  "professional services": "ProfessionalService",
+  photographer: "ProfessionalService",
+  "event venue": "EventVenue",
+  nonprofit: "NGO",
+  "music venue": ["LocalBusiness", "MusicVenue"],
+  "service business": "ProfessionalService",
+};
+
+const typeKey = (type) =>
+  String(type ?? "")
+    .normalize("NFD")
+    .replace(/[̀-ͯ]/g, "")
+    .trim()
+    .toLowerCase();
+
+const isEmpty = (value) =>
+  value === undefined ||
+  value === null ||
+  value === "" ||
+  (Array.isArray(value) && value.length === 0) ||
+  (typeof value === "object" &&
+    !Array.isArray(value) &&
+    Object.keys(value).every((key) => key === "@type" || isEmpty(value[key])));
+
+const compact = (node) =>
+  Object.fromEntries(Object.entries(node).filter(([, value]) => !isEmpty(value)));
+
+const httpUrls = (links) =>
+  (Array.isArray(links) ? links : [])
+    .map(textValue)
+    .filter((link) => link && /^https?:\/\//i.test(link));
+
+export function hasBusinessFacts(business) {
+  if (!business || typeof business !== "object") return false;
+  return (
+    ["name", "type", "address", "phone", "email", "hoursNote", "priceRange", "serviceArea", "siteIconUrl"].some(
+      (key) => textValue(business[key]),
+    ) ||
+    httpUrls(business.links).length > 0 ||
+    (Array.isArray(business.hours) && business.hours.length > 0)
+  );
+}
+
+export function businessSchemaType(type, { hasLocalDetails, fallback = "Organization" } = {}) {
+  const mapped = BUSINESS_SCHEMA_TYPES[typeKey(type)];
+  if (mapped) return mapped;
+  return hasLocalDetails ? "LocalBusiness" : fallback;
+}
+
+function scrapedCoordinates(scraped) {
+  const latitude = scraped?.geo?.latitude;
+  const longitude = scraped?.geo?.longitude;
+  if (latitude === undefined || longitude === undefined) return undefined;
+  return { "@type": "GeoCoordinates", latitude, longitude };
+}
+
+export function businessNode({ business, origin, scraped, geocoded, fallbackType }) {
+  const hours = openingHoursSpecification(businessHours(business.hours).valid);
+  const priceRange = PRICE_RANGES.has(business.priceRange) ? business.priceRange : undefined;
+  const address = textValue(business.address);
+  const located = locatedAddress(address, geocoded);
+  const scrapedAddress = scraped?.address ? compact(scraped.address) : undefined;
+
+  return compact({
+    "@type": businessSchemaType(business.type, {
+      hasLocalDetails: hours.length > 0 || Boolean(priceRange),
+      fallback: fallbackType,
+    }),
+    "@id": `${origin}/#business`,
+    name: textValue(business.name),
+    url: `${origin}/`,
+    logo: textValue(business.siteIconUrl),
+    telephone: textValue(business.phone) ?? scraped?.telephone,
+    email: textValue(business.email),
+    address: located.address ?? scrapedAddress,
+    geo: address ? located.geo : scrapedCoordinates(scraped),
+    areaServed: textValue(business.serviceArea) ?? scraped?.areaServed?.[0]?.name,
+    openingHoursSpecification: hours,
+    priceRange,
+    sameAs: httpUrls(business.links),
+  });
+}
+
+export function faqNode(pairs, pageUrl) {
+  return {
+    "@type": "FAQPage",
+    "@id": `${pageUrl}#faq`,
+    mainEntity: pairs.map(({ question, answer }) => ({
+      "@type": "Question",
+      name: question,
+      acceptedAnswer: { "@type": "Answer", text: answer },
+    })),
+  };
+}
+
+export function businessPageLdJson({ page, business, questions, pageUrl }) {
+  const graph = [
+    compact({
+      "@type": "WebPage",
+      "@id": `${pageUrl}#webpage`,
+      url: pageUrl,
+      name: page.name,
+      description: page.description,
+      about: { "@id": business["@id"] },
+    }),
+    business,
+  ];
+  if (questions.length) graph.push(faqNode(questions, pageUrl));
+  return { "@context": SCHEMA_CONTEXT, "@graph": graph };
+}
+
+export function withFaq(pageLdJson, questions, pageUrl) {
+  if (!questions.length) return pageLdJson;
+  const { "@context": context, ...page } = pageLdJson;
+  return {
+    "@context": context ?? SCHEMA_CONTEXT,
+    "@graph": [page, faqNode(questions, pageUrl)],
+  };
+}

package/scripts/ssg-helmet/business-ld-json.test.mjs

@@ -0,0 +1,213 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  businessNode,
+  businessPageLdJson,
+  businessSchemaType,
+  hasBusinessFacts,
+  withFaq,
+} from "./business-ld-json.mjs";
+
+const ORIGIN = "https://wiltonhouse.com";
+const BUSINESS = {
+  name: "Wilton House",
+  type: "Bar",
+  address: "123 Main St, Portland, OR",
+  phone: "+1 503 555 0100",
+  email: "hello@wiltonhouse.com",
+  hours: [
+    { days: ["Mo", "Tu", "We", "Th"], opens: "16:00", closes: "24:00" },
+    { days: ["Fr", "Sa"], opens: "16:00", closes: "02:00" },
+    { days: ["Xx"], opens: "16:00", closes: "02:00" },
+  ],
+  priceRange: null,
+  serviceArea: "Portland metro",
+  links: ["https://instagram.com/wiltonhouse", "not a url"],
+  siteIconUrl: "https://cdn.example/icon.png",
+};
+
+const EDITOR_BUSINESS_TYPES = {
+  Restaurant: "Restaurant",
+  "Café": "CafeOrCoffeeShop",
+  Bar: "BarOrPub",
+  Bakery: "Bakery",
+  Shop: "Store",
+  "Online store": "OnlineStore",
+  Florist: "Florist",
+  "Salon or spa": "BeautySalon",
+  "Fitness studio": "ExerciseGym",
+  "Health clinic": "MedicalClinic",
+  "Repair shop": "LocalBusiness",
+  "Home services": "HomeAndConstructionBusiness",
+  "Professional services": "ProfessionalService",
+  Photographer: "ProfessionalService",
+  "Event venue": "EventVenue",
+  Nonprofit: "NGO",
+};
+
+test("every editor business type maps to its schema.org type", () => {
+  for (const [type, schemaType] of Object.entries(EDITOR_BUSINESS_TYPES)) {
+    assert.equal(businessSchemaType(type), schemaType, type);
+  }
+});
+
+test("business types match without accents or case, and the extra keys stay", () => {
+  assert.equal(businessSchemaType("cafe"), "CafeOrCoffeeShop");
+  assert.equal(businessSchemaType("  SALON OR SPA "), "BeautySalon");
+  assert.equal(businessSchemaType("online Store"), "OnlineStore");
+  assert.deepEqual(businessSchemaType("Music venue"), ["LocalBusiness", "MusicVenue"]);
+  assert.equal(businessSchemaType("Service business"), "ProfessionalService");
+});
+
+test("a custom or unknown business type keeps the fallback", () => {
+  assert.equal(businessSchemaType("Dog groomer"), "Organization");
+  assert.equal(businessSchemaType("Dog groomer", { hasLocalDetails: true }), "LocalBusiness");
+  assert.equal(businessSchemaType(null, { hasLocalDetails: true }), "LocalBusiness");
+  assert.equal(businessSchemaType(null, { fallback: "OnlineStore" }), "OnlineStore");
+});
+
+test("the business node carries the owner's facts and no invented price range", () => {
+  const node = businessNode({ business: BUSINESS, origin: ORIGIN, scraped: {} });
+
+  assert.equal(node["@type"], "BarOrPub");
+  assert.equal(node["@id"], "https://wiltonhouse.com/#business");
+  assert.equal(node.name, "Wilton House");
+  assert.equal(node.telephone, "+1 503 555 0100");
+  assert.equal(node.email, "hello@wiltonhouse.com");
+  assert.deepEqual(node.address, { "@type": "PostalAddress", streetAddress: "123 Main St, Portland, OR" });
+  assert.equal(node.areaServed, "Portland metro");
+  assert.deepEqual(node.sameAs, ["https://instagram.com/wiltonhouse"]);
+  assert.equal(node.logo, "https://cdn.example/icon.png");
+  assert.deepEqual(node.openingHoursSpecification, [
+    { "@type": "OpeningHoursSpecification", dayOfWeek: ["Monday", "Tuesday", "Wednesday", "Thursday"], opens: "16:00", closes: "00:00" },
+    { "@type": "OpeningHoursSpecification", dayOfWeek: ["Friday", "Saturday"], opens: "16:00", closes: "02:00" },
+  ]);
+  assert.equal("priceRange" in node, false);
+  assert.equal("geo" in node, false);
+});
+
+test("a chosen price range is kept, an invalid one is dropped", () => {
+  assert.equal(businessNode({ business: { ...BUSINESS, priceRange: "$$$" }, origin: ORIGIN }).priceRange, "$$$");
+  assert.equal("priceRange" in businessNode({ business: { ...BUSINESS, priceRange: "cheap" }, origin: ORIGIN }), false);
+});
+
+test("a trusted geocoder match adds the structured parts and coordinates to the owner's street", () => {
+  const node = businessNode({
+    business: BUSINESS,
+    origin: ORIGIN,
+    geocoded: {
+      streetNumber: "123",
+      locality: "Portland",
+      region: "OR",
+      regionName: "Oregon",
+      postCode: "97204",
+      country: "US",
+      countryName: "United States",
+      partialMatch: false,
+      precise: true,
+      latitude: 45.5,
+      longitude: -122.6,
+    },
+  });
+
+  assert.deepEqual(node.address, {
+    "@type": "PostalAddress",
+    streetAddress: "123 Main St",
+    addressLocality: "Portland",
+    addressRegion: "OR",
+    postalCode: "97204",
+    addressCountry: "US",
+  });
+  assert.deepEqual(node.geo, { "@type": "GeoCoordinates", latitude: 45.5, longitude: -122.6 });
+});
+
+test("a geocoder match on another street never replaces the owner's address", () => {
+  const node = businessNode({
+    business: { ...BUSINESS, address: "1 QA Test Street, Portland, OR 97201" },
+    origin: ORIGIN,
+    geocoded: {
+      streetNumber: "116",
+      locality: "Portland",
+      region: "OR",
+      regionName: "Oregon",
+      postCode: "97201",
+      country: "US",
+      countryName: "United States",
+      partialMatch: true,
+      precise: true,
+      latitude: 45.51,
+      longitude: -122.68,
+    },
+  });
+
+  assert.deepEqual(node.address, {
+    "@type": "PostalAddress",
+    streetAddress: "1 QA Test Street",
+    addressLocality: "Portland",
+    addressRegion: "OR",
+    postalCode: "97201",
+  });
+  assert.equal("geo" in node, false);
+});
+
+test("scraped phone and address fill fields the owner left empty", () => {
+  const scraped = {
+    telephone: "+1 503 555 0199",
+    address: { "@type": "PostalAddress", streetAddress: "9 Side St", addressLocality: undefined },
+    geo: { "@type": "GeoCoordinates", latitude: 1, longitude: 2 },
+    areaServed: [{ "@type": "City", name: "Portland" }],
+  };
+  const node = businessNode({ business: { name: "Wilton House" }, origin: ORIGIN, scraped });
+
+  assert.equal(node["@type"], "Organization");
+  assert.equal(node.telephone, "+1 503 555 0199");
+  assert.deepEqual(node.address, { "@type": "PostalAddress", streetAddress: "9 Side St" });
+  assert.deepEqual(node.geo, { "@type": "GeoCoordinates", latitude: 1, longitude: 2 });
+  assert.equal(node.areaServed, "Portland");
+});
+
+test("a scraped address without a street line keeps its confirmed locality, region and postcode", () => {
+  const scraped = {
+    address: { "@type": "PostalAddress", streetAddress: undefined, addressLocality: "Plano", addressRegion: "TX", postalCode: "75074" },
+    geo: { "@type": "GeoCoordinates", latitude: undefined, longitude: undefined },
+  };
+  const node = businessNode({ business: { name: "Xpress Oil & Auto" }, origin: ORIGIN, scraped });
+
+  assert.deepEqual(node.address, { "@type": "PostalAddress", addressLocality: "Plano", addressRegion: "TX", postalCode: "75074" });
+  assert.equal("geo" in node, false);
+  assert.equal("address" in businessNode({ business: { name: "Xpress Oil & Auto" }, origin: ORIGIN, scraped: { address: { "@type": "PostalAddress" } } }), false);
+});
+
+test("all-default business settings are no business facts", () => {
+  assert.equal(hasBusinessFacts({ name: null, type: null, hours: [], links: [], yours: {} }), false);
+  assert.equal(hasBusinessFacts({ hours: [{ days: ["Mo"], opens: "09:00", closes: "17:00" }] }), true);
+  assert.equal(hasBusinessFacts({ hours: [], hoursNote: "Closed on public holidays" }), true);
+  assert.equal(hasBusinessFacts(undefined), false);
+});
+
+test("a page graph links the page to the business and adds questions when present", () => {
+  const business = businessNode({ business: BUSINESS, origin: ORIGIN });
+  const questions = [{ question: "Do you take reservations?", answer: "Yes, for six or more." }];
+  const ld = businessPageLdJson({ page: { name: "About", description: "Our story" }, business, questions, pageUrl: `${ORIGIN}/about` });
+
+  assert.equal(ld["@context"], "https://schema.org");
+  assert.deepEqual(ld["@graph"][0], {
+    "@type": "WebPage",
+    "@id": "https://wiltonhouse.com/about#webpage",
+    url: "https://wiltonhouse.com/about",
+    name: "About",
+    description: "Our story",
+    about: { "@id": "https://wiltonhouse.com/#business" },
+  });
+  assert.equal(ld["@graph"][1], business);
+  assert.equal(ld["@graph"][2]["@type"], "FAQPage");
+  assert.equal(ld["@graph"][2].mainEntity[0].acceptedAnswer.text, "Yes, for six or more.");
+  assert.doesNotMatch(JSON.stringify(ld), /"\$\$"/);
+});
+
+test("without questions the fallback page object is left exactly as it was", () => {
+  const page = { "@context": "https://schema.org", "@type": "WebPage", name: "Home" };
+
+  assert.equal(withFaq(page, [], ORIGIN), page);
+  assert.deepEqual(withFaq(page, [{ question: "Q?", answer: "A a a" }], ORIGIN)["@graph"][0], { "@type": "WebPage", name: "Home" });
+});