@mindful-web/marko-web-digital-edition 1.95.0

package/lib/index.js

@@ -0,0 +1,453 @@
+const { existsSync, readFileSync } = require('fs');
+const { resolve } = require('path');
+const entities = require('./entities');
+
+/**
+ * Digital edition support.
+ *
+ * The edition is described entirely by a committed manifest JSON,
+ * `<configDir>/<issueId>.json`, produced by the digital-edition ingest pipeline.
+ * Nothing here reads or writes CMS fields — page images and ad crops are imgix URLs
+ * built from the issue PDF that already hangs off the magazine issue.
+ *
+ * When this graduates, the manifest moves to a Mongo collection and this loader is
+ * replaced by a GraphQL query; the shapes below are meant to survive that move.
+ */
+
+/**
+ * Per-process defaults, set once by the routes factory. A website process serves a
+ * single site, so module state is the right scope: it keeps `editionPath` callable
+ * from every template without threading the mount point through each call.
+ */
+const defaults = {
+  configDir: null,
+  mountPoint: '/magazine',
+};
+
+const configure = ({ configDir, mountPoint } = {}) => {
+  if (configDir) defaults.configDir = resolve(configDir);
+  if (mountPoint) defaults.mountPoint = mountPoint.replace(/\/+$/, '');
+  return { ...defaults };
+};
+
+const cache = new Map();
+
+/** Load a manifest by issue id, or null when the issue has no edition. */
+const loadManifest = (issueId, { configDir = defaults.configDir } = {}) => {
+  const id = String(issueId);
+  if (!/^\d+$/.test(id)) return null;
+  if (!configDir) throw new Error('marko-web-digital-edition: no configDir configured. Pass it to the routes factory.');
+  const key = `${configDir}:${id}`;
+  if (cache.has(key)) return cache.get(key);
+  const path = resolve(configDir, `${id}.json`);
+  const manifest = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : null;
+  // Cache misses too — a missing edition is the common case on a 404 probe.
+  if (process.env.NODE_ENV === 'production') cache.set(key, manifest);
+  return manifest;
+};
+
+const qs = (params) => Object.entries(params)
+  .filter(([, v]) => v !== undefined && v !== null && v !== '')
+  .map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
+  .join('&');
+
+const baseUrl = ({ host, key }) => `https://${host}/${String(key).replace(/^\/+/, '')}`;
+
+/**
+ * Full-page render.
+ * imgix rasterises PDF pages natively via `page=N`.
+ */
+const pageImageUrl = (manifest, page, { w = 1200, fm = 'webp', dpr } = {}) => `${baseUrl(manifest.pdf)}?${qs({
+  page, fm, w, dpr,
+})}`;
+
+/**
+ * Region crop.
+ * `bbox` is [x, y, w, h] as FRACTIONS of the page. imgix `rect` wants integers in
+ * the PDF's base render space (manifest.pdf.baseWidth/baseHeight), so multiply here
+ * and nowhere else.
+ */
+const cropUrl = (manifest, page, bbox, {
+  w = 1400, fm = 'webp', dpr, pad = 0,
+} = {}) => {
+  const { baseWidth: bw, baseHeight: bh } = manifest.pdf;
+  const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+  const x0 = clamp((bbox[0] - pad) * bw, 0, bw);
+  const y0 = clamp((bbox[1] - pad) * bh, 0, bh);
+  const x1 = clamp((bbox[0] + bbox[2] + pad) * bw, 0, bw);
+  const y1 = clamp((bbox[1] + bbox[3] + pad) * bh, 0, bh);
+  const rect = [
+    Math.round(x0), Math.round(y0),
+    Math.max(1, Math.round(x1 - x0)), Math.max(1, Math.round(y1 - y0)),
+  ].join(',');
+  return `${baseUrl(manifest.pdf)}?${qs({
+    page, rect, fm, w, dpr,
+  })}`;
+};
+
+/** `srcset` across a few widths, so phones don't pull a 1600px page image. */
+const pageSrcset = (manifest, page, widths = [480, 800, 1200, 1600]) => widths
+  .map((w) => `${pageImageUrl(manifest, page, { w })} ${w}w`)
+  .join(', ');
+
+const cropSrcset = (manifest, page, bbox, widths = [480, 800, 1200]) => widths
+  .map((w) => `${cropUrl(manifest, page, bbox, { w })} ${w}w`)
+  .join(', ');
+
+/** Aspect ratio of the printed page, so the replica reserves layout space. */
+const pageAspect = (manifest) => manifest.pdf.baseWidth / manifest.pdf.baseHeight;
+
+const isAd = (item) => item.kind === 'ad' || item.kind === 'advertorial' || item.kind === 'house_ad';
+
+/**
+ * An editorial item that earns a URL. Requires a non-empty reflow body: a group
+ * whose only text is its headline (p46's "We're Exhibiting at…" panel introducing a
+ * paid exhibitor showcase) would otherwise publish as a thin, headline-only page.
+ */
+const isPublishable = (item) => item.kind === 'article' && Boolean(item.slug) && item.bodyChars > 0;
+
+/**
+ * Articles held from search by the ingest (`noindex: true` on the item). They stay
+ * readable and linked for subscribers, but emit a robots noindex and are left out
+ * of the issue's structured-data contents.
+ */
+const isIndexable = (item) => !item.noindex;
+
+/** Contents entries for the reflow TOC — editorial only. */
+const tocItems = (manifest) => manifest.items
+  .filter((i) => isPublishable(i) && i.headline)
+  .sort((a, b) => a.printPage - b.printPage);
+
+/** Ad regions that carry a landing URL, keyed by page, for replica hotspots. */
+const hotspotsForPage = (manifest, pageNumber) => {
+  const page = manifest.pages.find((p) => p.n === pageNumber);
+  if (!page) return [];
+  return page.regions.filter((r) => r.href);
+};
+
+const anchorFor = (item) => `item-${String(item.id).replace(/[^a-z0-9]+/gi, '-')}`;
+
+/**
+ * Canonical path for an issue's digital edition — a child of the magazine issue
+ * route (`<mountPoint>/<issueId>/digital-edition`). Defined here only, so the route,
+ * the toolbar links and the canonical URL cannot drift apart.
+ */
+const editionPath = (issueId, { view, slug, mountPoint = defaults.mountPoint } = {}) => {
+  const base = `${mountPoint}/${issueId}/digital-edition`;
+  if (slug) return `${base}/${slug}`;
+  return view === 'print' ? `${base}?view=print` : base;
+};
+
+/** Publishable articles in print order — the spine of the reader and of prev/next. */
+const articles = (manifest) => manifest.items
+  .filter(isPublishable)
+  .slice()
+  .sort((a, b) => a.printSequence - b.printSequence);
+
+const articleBySlug = (manifest, slug) => articles(manifest).find((a) => a.slug === slug) || null;
+
+/**
+ * Neighbours by reading order. `printSequence` comes from the grouping pass and skips
+ * numbers (advertorial groups consume them), so position in the filtered list is what
+ * matters, not the raw sequence value.
+ */
+const prevNext = (manifest, slug) => {
+  const list = articles(manifest);
+  const i = list.findIndex((a) => a.slug === slug);
+  if (i === -1) {
+    return {
+      prev: null, next: null, position: null, total: list.length,
+    };
+  }
+  return {
+    prev: i > 0 ? list[i - 1] : null,
+    next: i < list.length - 1 ? list[i + 1] : null,
+    position: i + 1,
+    total: list.length,
+  };
+};
+
+// ---------------------------------------------------------------------------
+// In-article ad placement.
+//
+// Print put every ad on a page inside or facing the article it ran beside; the
+// reflow reader keeps that adjacency by floating the ad into the article body at
+// the depth matching its print position. Each paid ad is claimed by exactly ONE
+// article — pass A: the article whose page span contains the ad's page (tie →
+// earlier print sequence); pass B: the article one page away (tie → earlier
+// sequence). Claims big enough to float (≥ ~15% of a page — p77's 4:1 directory
+// strips are not) go inline; the rest trail the article at roughly print scale.
+// ---------------------------------------------------------------------------
+
+/** Floats smaller than this fraction of a page cannot carry a wrap. */
+const INLINE_MIN_AREA = 0.15;
+/** Minimum paragraphs of copy between two floats, tuned to a full-page ad's height. */
+const INLINE_MIN_GAP = 4;
+/** Articles shorter than this trail everything — no room for a wrap. */
+const INLINE_MIN_PARAS = 4;
+
+/**
+ * Paragraph slots of a reflow body. Bodies are flat `<p>`/`<h2>` HTML from the
+ * ingest compose stage, so a tag scan is structural, not heuristic. Slot i sits
+ * after the (i+1)-th `</p>` and can host a float only when a `<p>` follows — a
+ * float directly above an `<h2>` reads as belonging to the previous section.
+ */
+const bodySlots = (bodyHtml) => {
+  const html = String(bodyHtml || '');
+  const slots = [];
+  const re = /<\/p>/g;
+  let m = re.exec(html);
+  while (m) {
+    const end = m.index + m[0].length;
+    slots.push({ end, floatable: /^\s*<p[\s>]/.test(html.slice(end, end + 12)) });
+    m = re.exec(html);
+  }
+  return slots;
+};
+
+const spanOf = (a) => {
+  const refs = a.pageRefs && a.pageRefs.length ? a.pageRefs : [a.printPage];
+  return { lo: Math.min(...refs), hi: Math.max(...refs) };
+};
+
+const buildPlacements = (manifest) => {
+  const arts = articles(manifest);
+  const claims = new Map();
+  arts.forEach((a) => claims.set(a.id, []));
+
+  manifest.items.filter((i) => i.kind === 'ad').forEach((ad) => {
+    // Pass A: span containment. `arts` is in printSequence order, so the first
+    // match is the tie-break.
+    let owner = arts.find((a) => {
+      const s = spanOf(a);
+      return ad.printPage >= s.lo && ad.printPage <= s.hi;
+    });
+    if (!owner) {
+      // Pass B: facing page.
+      owner = arts.find((a) => {
+        const s = spanOf(a);
+        return ad.printPage === s.lo - 1 || ad.printPage === s.hi + 1;
+      });
+    }
+    if (owner) claims.get(owner.id).push(ad);
+  });
+
+  const placements = new Map();
+  arts.forEach((a) => {
+    const claimed = claims.get(a.id);
+    const slots = bodySlots(a.bodyHtml);
+    const pCount = slots.length;
+    const inline = [];
+    const trailing = [];
+    // Print order: page, then top of page — this decides which ad comes first,
+    // even though the depths themselves are evenly distributed below.
+    claimed.sort((x, y) => x.printPage - y.printPage || x.bbox[1] - y.bbox[1]);
+
+    const candidates = [];
+    claimed.forEach((ad) => {
+      const area = ad.bbox ? ad.bbox[2] * ad.bbox[3] : 0;
+      if (area < INLINE_MIN_AREA || pCount < INLINE_MIN_PARAS) trailing.push(ad);
+      else candidates.push(ad);
+    });
+
+    // Even distribution through the copy: one ad sits ~50% of the way through,
+    // two at ~33%/66%, three at 25/50/75 — j/(N+1). Print position decides the
+    // ORDER of the ads, not their depth: mapping depth from the ad's print page
+    // put a facing-page ad at 100% and it beached at the very end of the body.
+    let lastSlot = -Infinity;
+    candidates.forEach((ad, j) => {
+      const fraction = (j + 1) / (candidates.length + 1);
+      const target = Math.min(Math.max(Math.round(fraction * pCount), 2), pCount - 1);
+      const floor = Math.max(1, lastSlot + INLINE_MIN_GAP);
+      const start = Math.max(target - 1, floor);
+      let chosen = -1;
+      for (let i = start; i <= pCount - 2; i += 1) {
+        if (slots[i].floatable) { chosen = i; break; }
+      }
+      for (let i = Math.min(start, pCount - 2); chosen === -1 && i >= floor; i -= 1) {
+        if (slots[i].floatable) chosen = i;
+      }
+      if (chosen === -1) {
+        trailing.push(ad);
+        return;
+      }
+      inline.push({ ad, slot: chosen });
+      lastSlot = chosen;
+    });
+
+    placements.set(a.id, { inline, trailing });
+  });
+  return placements;
+};
+
+// The manifest object is cached per issue in production, so placements memoize
+// against it; in dev the manifest is re-read per request and this is a cheap miss.
+const placementCache = new WeakMap();
+const inlineAdPlacements = (manifest) => {
+  if (placementCache.has(manifest)) return placementCache.get(manifest);
+  const placements = buildPlacements(manifest);
+  placementCache.set(manifest, placements);
+  return placements;
+};
+
+/**
+ * One article's body, split for rendering: `segments` in order, each an html
+ * chunk optionally preceded by an inline (floated) ad; `trailing` ads render
+ * after the article body at print scale.
+ */
+const articleAdLayout = (manifest, item) => {
+  const plan = inlineAdPlacements(manifest).get(item.id) || { inline: [], trailing: [] };
+  const html = String(item.bodyHtml || '');
+  const slots = bodySlots(html);
+  const sorted = plan.inline.slice().sort((x, y) => x.slot - y.slot);
+  const cuts = sorted.map((p) => slots[p.slot].end);
+  const segments = [{ ad: null, html: html.slice(0, cuts.length ? cuts[0] : html.length) }];
+  sorted.forEach((p, i) => {
+    segments.push({
+      ad: p.ad,
+      html: html.slice(cuts[i], i + 1 < cuts.length ? cuts[i + 1] : html.length),
+    });
+  });
+  return { segments, trailing: plan.trailing };
+};
+
+/**
+ * Canonical URL for one article.
+ *
+ * A print-exclusive article is original content and self-canonicalizes. An article
+ * matched to an existing web article points at that instead, so the edition does not
+ * compete with it. Returned absolute — a relative canonical is a silent no-op.
+ */
+const articleCanonical = ({ manifest, item, requestOrigin }) => {
+  const origin = requestOrigin || '';
+  if (item.match && item.match.path) return `${origin}${item.match.path}`;
+  return `${origin}${editionPath(manifest.issueId, { slug: item.slug })}`;
+};
+
+/** First paragraph only — what an unentitled visitor is allowed to read. */
+const teaserHtml = (item) => {
+  const html = String(item.bodyHtml || '');
+  const end = html.indexOf('</p>');
+  return end === -1 ? '' : html.slice(0, end + 4);
+};
+
+/**
+ * Google "paywalled content" structured data for an issue.
+ *
+ * Mirrors what content pages already emit from marko-web's
+ * `page/metadata/google-structured-data/content.js` (isAccessibleForFree:false plus
+ * hasPart.cssSelector). That helper is content-node specific and lives in
+ * mindful-web, so the issue-level equivalent lives here.
+ *
+ * This is what lets the edition be gated AND indexable.
+ */
+const buildLdJson = ({ manifest, gated, canonicalUrl }) => {
+  // Held (noindex) articles are omitted: advertising a part we ask Google not to
+  // index is a conflicting signal.
+  const toc = tocItems(manifest).filter(isIndexable);
+  const parts = toc.slice(0, 60).map((i) => {
+    const part = {
+      '@type': 'Article',
+      headline: i.headline,
+      pagination: String(i.printPage),
+      isAccessibleForFree: !gated,
+    };
+    if (i.byline) part.author = { '@type': 'Person', name: i.byline };
+    if (i.match && i.match.path) part.sameAs = i.match.path;
+    return part;
+  });
+  if (gated) {
+    parts.push({
+      '@type': 'WebPageElement',
+      isAccessibleForFree: false,
+      cssSelector: '.edition-gated-body',
+    });
+  }
+  const ld = {
+    '@context': 'https://schema.org',
+    '@type': 'PublicationIssue',
+    name: `${manifest.publication} — ${manifest.name}`,
+    issueNumber: String(manifest.issueId),
+    isAccessibleForFree: !gated,
+    isPartOf: { '@type': 'Periodical', name: manifest.publication },
+  };
+  if (manifest.mailed) ld.datePublished = new Date(manifest.mailed).toISOString();
+  if (canonicalUrl) {
+    ld.url = canonicalUrl;
+    ld.mainEntityOfPage = { '@type': 'WebPage', '@id': canonicalUrl };
+  }
+  if (manifest.coverImage) ld.image = manifest.coverImage;
+  if (parts.length) ld.hasPart = parts;
+  return ld;
+};
+
+/**
+ * Structured data for a single article page. Separate from the issue-level
+ * PublicationIssue block: this is what makes an individual story citable.
+ */
+const buildArticleLdJson = ({
+  manifest, item, canonicalUrl, gated, authorNode, requestOrigin,
+}) => {
+  const ld = {
+    '@context': 'https://schema.org',
+    '@type': 'Article',
+    headline: item.headline || undefined,
+    isAccessibleForFree: !gated,
+    mainEntityOfPage: { '@type': 'WebPage', '@id': canonicalUrl },
+    url: canonicalUrl,
+    isPartOf: {
+      '@type': 'PublicationIssue',
+      name: `${manifest.publication} — ${manifest.name}`,
+      issueNumber: String(manifest.issueId),
+    },
+    publisher: { '@type': 'Organization', name: manifest.publication },
+  };
+  if (item.deck) ld.description = item.deck;
+  if (item.printPage) ld.pagination = String(item.printPage);
+  if (manifest.mailed) ld.datePublished = new Date(manifest.mailed).toISOString();
+  if (manifest.coverImage) ld.image = manifest.coverImage;
+  if (gated) {
+    ld.hasPart = [{
+      '@type': 'WebPageElement',
+      isAccessibleForFree: false,
+      cssSelector: '.edition-gated-body',
+    }];
+  }
+  if (authorNode) {
+    ld.author = { '@type': 'Person', name: authorNode.name };
+    if (authorNode.siteContext && authorNode.siteContext.path) {
+      ld.author.sameAs = `${requestOrigin || ''}${authorNode.siteContext.path}`;
+    }
+    if (authorNode.title) ld.author.jobTitle = authorNode.title;
+  } else if (item.byline) {
+    ld.author = { '@type': 'Person', name: item.byline };
+  }
+  return ld;
+};
+
+module.exports = {
+  configure,
+  loadManifest,
+  pageImageUrl,
+  pageSrcset,
+  cropUrl,
+  cropSrcset,
+  pageAspect,
+  tocItems,
+  hotspotsForPage,
+  anchorFor,
+  isAd,
+  isPublishable,
+  isIndexable,
+  buildLdJson,
+  teaserHtml,
+  editionPath,
+  articles,
+  articleBySlug,
+  prevNext,
+  inlineAdPlacements,
+  articleAdLayout,
+  articleCanonical,
+  buildArticleLdJson,
+  ...entities,
+};

package/marko.json

@@ -0,0 +1,6 @@
+{
+  "taglib-id": "@mindful-web/marko-web-digital-edition",
+  "taglib-imports": [
+    "./components/marko.json"
+  ]
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@mindful-web/marko-web-digital-edition",
+  "version": "1.95.0",
+  "description": "Native digital edition (reflow + replica readers) for magazine issues, driven by an ingest manifest, for Mindful Web/Marko websites.",
+  "author": "Brandon Krigbaum <brandon@parameter1.com>",
+  "license": "MIT",
+  "repository": "https://github.com/parameter1/mindful-web/tree/main/packages/marko-web-digital-edition",
+  "scripts": {
+    "lint:fix": "yarn lint --fix",
+    "lint": "eslint --ext .js --ext .vue --max-warnings 5 ./",
+    "compile": "mindful-web-marko-compile compile",
+    "prepublish": "yarn compile --silent",
+    "test": "yarn compile --no-clean && yarn lint"
+  },
+  "dependencies": {
+    "@mindful-web/marko-web-gtm": "^1.92.0",
+    "@mindful-web/marko-web-identity-x": "^1.92.0",
+    "@mindful-web/marko-web-p1-events": "^1.93.1",
+    "@mindful-web/object-path": "^1.92.0",
+    "@mindful-web/utils": "^1.92.0",
+    "graphql": "^14.7.0",
+    "graphql-tag": "^2.12.6",
+    "http-errors": "^1.7.3"
+  },
+  "peerDependencies": {
+    "@mindful-web/marko-core": "^1.0.0",
+    "@mindful-web/marko-web": "^1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "ca256c07007f7e4bed54d6e7b79df0f53b0b3a0a"
+}

package/routes/index.js

@@ -0,0 +1,129 @@
+const createError = require('http-errors');
+const { asyncRoute } = require('@mindful-web/utils');
+const hubTemplate = require('../templates/hub');
+const articleTemplate = require('../templates/article');
+const partialTemplate = require('../templates/partial');
+const { attachAuthors } = require('../lib/authors');
+const {
+  configure, loadManifest, editionPath, articles, articleBySlug, prevNext, articleCanonical,
+} = require('../lib');
+
+/**
+ * Native digital edition — a child of the magazine issue it belongs to.
+ *
+ *   <mountPoint>/32023/digital-edition                    hub: cover, contents, first article
+ *   <mountPoint>/32023/digital-edition?view=print         replica page view
+ *   <mountPoint>/32023/digital-edition/<slug>             one article, server-rendered
+ *   <mountPoint>/32023/digital-edition/<slug>?partial=1   fragment for the scroll reader
+ *
+ * Every article has a real URL so it is independently crawlable and citable; the hub's
+ * continuous-scroll reader appends those same URLs' fragments and pushStates to them.
+ *
+ * Mount this BEFORE the site's magazine routes so a future loosening of the issue
+ * pattern cannot swallow these child routes.
+ *
+ * Options:
+ *   configDir       required. Directory holding `<issueId>.json` manifests.
+ *   mountPoint      URL prefix the issue lives under. Default `/magazine`.
+ *   siteId          () => the running site's id. Default `app.locals.config.website('id')`.
+ *                   A manifest whose `siteId` differs is a 404: shared packages ship to
+ *                   every site in a repo, and only the issue's own site may serve it.
+ *   noIndexKey      site-config path that, when truthy, emits a robots noindex on every
+ *                   edition page (a review hold). Default `digitalEdition.native.noIndex`.
+ *   authorNode      optional compiled Marko template rendering `{ author }` — e.g. the
+ *                   monorail theme's `components/nodes/author.marko`. Without it the
+ *                   byline renders as a plain (linked) name.
+ *   templates       optional overrides: `{ hub, article, partial }`.
+ *   legacyRedirect  when true, 301 `/edition/:issueId` → the hub (the AB spike's first URL).
+ */
+module.exports = (app, {
+  configDir,
+  mountPoint = '/magazine',
+  siteId = () => app.locals.config.website('id'),
+  noIndexKey = 'digitalEdition.native.noIndex',
+  authorNode = null,
+  templates = {},
+  legacyRedirect = false,
+} = {}) => {
+  if (!configDir) throw new Error('marko-web-digital-edition routes: `configDir` is required.');
+  const resolved = configure({ configDir, mountPoint });
+  const base = resolved.mountPoint;
+
+  // Reaches templates as `out.global.digitalEdition` (app.locals merge into out.global).
+  const { locals } = app;
+  locals.digitalEdition = { mountPoint: base, noIndexKey, authorNode };
+
+  const hub = templates.hub || hubTemplate;
+  const article = templates.article || articleTemplate;
+  const partial = templates.partial || partialTemplate;
+
+  /** Resolve the issue for this site, or 404. */
+  const getManifest = (req) => {
+    const issueId = Number(req.params.issueId);
+    const manifest = loadManifest(issueId);
+    if (!manifest || manifest.siteId !== siteId()) {
+      throw createError(404, `No digital edition has been published for issue ${issueId}.`);
+    }
+    return manifest;
+  };
+
+  // --- single article (and its fragment) ------------------------------------
+  app.get(`${base}/:issueId(\\d+)/digital-edition/:slug([a-z0-9-]+)`, asyncRoute(async (req, res) => {
+    const manifest = getManifest(req);
+    const item = articleBySlug(manifest, req.params.slug);
+    if (!item) throw createError(404, `No article "${req.params.slug}" in issue ${manifest.issueId}.`);
+
+    await attachAuthors({
+      apollo: req.apollo, siteId: siteId(), items: [item],
+    });
+
+    if (req.query.partial) {
+      // Entitlement is resolved inside the template by the same access component the
+      // page uses. Private + no-store because the response varies by reader. The
+      // article's print-adjacent ads render inside the article component itself.
+      res.set('cache-control', 'private, no-store');
+      return res.marko(partial, { manifest, item });
+    }
+
+    const {
+      prev, next, position, total,
+    } = prevNext(manifest, item.slug);
+    return res.marko(article, {
+      manifest,
+      item,
+      canonicalUrl: articleCanonical({ manifest, item, requestOrigin: res.locals.requestOrigin || '' }),
+      prev,
+      next,
+      position,
+      total,
+      toc: articles(manifest),
+    });
+  }));
+
+  // --- hub -----------------------------------------------------------------
+  app.get(`${base}/:issueId(\\d+)/digital-edition`, asyncRoute(async (req, res) => {
+    const manifest = getManifest(req);
+    const view = req.query.view === 'print' ? 'print' : 'read';
+    const { pageCount } = manifest.pdf;
+    const requested = Number.parseInt(req.query.page, 10);
+    const page = Number.isFinite(requested) ? Math.min(Math.max(requested, 1), pageCount) : 1;
+
+    // Only the first article is rendered into the hub, so only it needs an author.
+    if (view === 'read') {
+      const first = articles(manifest)[0];
+      if (first) await attachAuthors({ apollo: req.apollo, siteId: siteId(), items: [first] });
+    }
+
+    return res.marko(hub, {
+      manifest, view, page, issueId: manifest.issueId,
+    });
+  }));
+
+  if (legacyRedirect) {
+    app.get('/edition/:issueId(\\d+)', (req, res) => {
+      const qs = req.originalUrl.split('?')[1];
+      const to = editionPath(req.params.issueId) + (qs ? `?${qs}` : '');
+      res.redirect(301, to);
+    });
+  }
+};