@iterant/site-runtime 3.12.0 → 3.13.0

package/bin/site-runtime.mjs

@@ -5,6 +5,7 @@
  * brand repo root.
  *
  *   site-runtime verify                    # the gate: fonts, islands, lint, check, tests, build, bespoke siblings, editor bytes
+ *   site-runtime verify --lint <path...>   # the same gate, linting only those paths (none: skip the lint step)
  *   site-runtime scan-copy [files...]      # hardcoded visible copy in component code
  *   site-runtime scan-island-imports [dir] # island-grade ui primitives imported by registered sections
  *   site-runtime scan-bespoke-siblings     # bespoke locale-sibling hydration contract (after a build)

package/docs/runtime-contract.md

@@ -50,7 +50,7 @@ runtime and says so.
 
 <!-- generated: available libraries -->
 
-_Generated from package.json by scripts/generate-kit-table.mjs. Runtime 3.12.0._
+_Generated from package.json by scripts/generate-kit-table.mjs. Runtime 3.13.0._
 
 **Toolchain** (this package owns the version; do NOT declare these):
 
@@ -590,15 +590,15 @@ reached through one forwarding rule, `example.com/feed/*`, and anything a page
 asks for outside that prefix 404s on the customer's site. So with
 `folder: "feed"` set:
 
-| What                             | Where it lands                          |
-| -------------------------------- | --------------------------------------- |
-| hashed assets (`build.assets`)   | `/feed/_astro/*`, fonts included        |
-| immutable `Cache-Control` rule   | `/feed/_astro/*`, written by the adapter |
-| sitemap index and its children   | `/feed/sitemap-index.xml`, `/feed/sitemap-0.xml` |
-| llms.txt                         | `/feed/llms.txt`, injected by the preset |
-| the head's icon link             | `/feed/favicon.ico`                     |
-| robots.txt                       | the root, with its `Sitemap:` line in the folder |
-| the mirrored legacy sitemaps     | the root, the URLs the old site advertised |
+| What                           | Where it lands                                   |
+| ------------------------------ | ------------------------------------------------ |
+| hashed assets (`build.assets`) | `/feed/_astro/*`, fonts included                 |
+| immutable `Cache-Control` rule | `/feed/_astro/*`, written by the adapter         |
+| sitemap index and its children | `/feed/sitemap-index.xml`, `/feed/sitemap-0.xml` |
+| llms.txt                       | `/feed/llms.txt`, injected by the preset         |
+| the head's icon link           | `/feed/favicon.ico`                              |
+| robots.txt                     | the root, with its `Sitemap:` line in the folder |
+| the mirrored legacy sitemaps   | the root, the URLs the old site advertised       |
 
 **Pages do not move.** A page keeps the public path it is authored at, in every
 serving mode, and every `<loc>` in the sitemap is that same path. The folder is
@@ -622,6 +622,90 @@ since the preset addresses that route. A repo that keeps the root file still
 builds and still serves `/llms.txt`, at a URL the customer's domain does not
 forward; the build warns until the file is deleted.
 
+### What 3.13.0 changes in every scope
+
+Three things differ from 3.12.0 even with the scope left at its default:
+
+- The BreadcrumbList folds the brand folder and the locale into its root crumb
+  (`/feed/es` for a translated page under the folder, `/feed` for a plain one),
+  so no crumb points at `/` and no crumb is named after the folder. A page that
+  is the folder index alone emits no BreadcrumbList.
+- The sitemap lists a route once when a prerendered page and a content entry
+  share it; the first one the plugin sees wins.
+- The package root no longer exports `pageLocaleHead`: it reads the virtual
+  site module, and the root stays importable outside an Astro build. Pages
+  import it from `@iterant/site-runtime/hreflang`, as the starter always did.
+  The pure `deriveHreflangAlternates` takes the scope as a required argument.
+- `verify` accepts exactly one option, `--lint <path...>`; any other option,
+  including `--lint=path`, is refused with exit 2.
+
+### The canonical scope (3.13.0)
+
+A production deploy bakes the CUSTOMER's origin into `site`, and in path routing
+the customer forwards one prefix: `/<folder>/*`, translations included, since a
+translated page lives under the folder (`/<folder>/<locale>/x`). Every other
+route of the build (the brand home at `/`, `/under-construction`, anything
+outside the folder) is served on the platform's own host alone. Spelling those
+against `site` points a crawler, and every link preview, at the customer's real
+homepage.
+
+The deploy states the scope in the build environment, not in the repo, because
+the same tree builds for both:
+
+| Variable                  | Value                                   |
+| ------------------------- | --------------------------------------- |
+| `ITERANT_CANONICAL_SCOPE` | `host` (the default) or `folder`        |
+| `ITERANT_PLATFORM_SITE`   | the platform origin, under folder scope |
+
+`folder` with no folder, or with no platform origin, fails the build: there is
+no safe reading of a deploy that would spell customer URLs for pages the
+customer never serves. `host` is what every build before this one declared, and
+under it every emitter below writes exactly the bytes it wrote then.
+
+Under `folder`, a path is IN scope when its first segment is the folder. The
+folder matches a whole segment, so `/feedback` is out of scope for the folder
+`feed`. Then:
+
+| Emitter                             | In scope                                    | Out of scope                    |
+| ----------------------------------- | ------------------------------------------- | ------------------------------- |
+| canonical, `og:url`, `og:image`     | the `site` origin                           | the platform origin             |
+| `<meta name="robots">`              | the page's own setting                      | `noindex, nofollow`             |
+| JSON-LD page `url` and `@id`        | the `site` origin                           | no graph at all (it is noindex) |
+| JSON-LD breadcrumb ancestors        | crumbs above the folder are DROPPED         | n/a                             |
+| hreflang alternates                 | the `site` origin                           | the platform origin             |
+| sitemap `<loc>`                     | listed                                      | left out                        |
+| llms.txt links                      | listed, `site` origin                       | left out                        |
+| robots.txt `Sitemap:` index line    | always, `{site}/<folder>/sitemap-index.xml` | n/a                             |
+| robots.txt mirrored `Sitemap:` line | n/a                                         | not advertised                  |
+
+Breadcrumb ancestors are dropped rather than relinked: `/` and the folder's
+locale root on the customer's domain lead to the customer's own homepage, and a
+crumb naming it would put the brand's trail on a page the brand does not own. A
+page whose only surviving crumb is itself emits no `BreadcrumbList`, the way a
+home page does.
+
+**llms.txt names no second host.** The file is read on whichever host served it,
+so a link to our origin inside the customer's copy advertises it to every
+assistant that reads the file. Under folder scope it carries only paths the
+customer serves: the pages inside the folder and the generated sitemap index.
+The Home line and the Robots policy line are at the root, so they go, and a
+section left with no lines goes with its heading.
+
+**robots.txt does not move.** It is a host-level file, read at the root of
+whichever host serves it. Its index line keeps naming
+`{site}/<folder>/sitemap-index.xml`, which is where the build writes the index.
+The MIRRORED sitemap (`sourceSitemapUrl`) is a root URL, so under folder scope
+it is not advertised at all; host scope advertises it exactly as before.
+
+**hreflang reads the scope itself.** `pageLocaleHead`
+(`@iterant/site-runtime/hreflang`) takes no scope argument: it reads it from the
+preset through the same virtual module the layout uses, so a page inside the
+folder advertises its siblings on the customer's domain and a page outside it
+advertises them on ours, with nothing for a repo to pass or get wrong. The pure
+derivation underneath, `deriveHreflangAlternates`, takes the scope as a required
+argument and is re-exported from the package root for callers outside an Astro
+build.
+
 ### Web fonts (3.8.0)
 
 A site names its font families once, in `SITE_CONFIG.fonts`, and passes the same
@@ -871,7 +955,12 @@ change is broken. In order:
 3. **island imports**: no island-grade ui primitive is imported under
    `src/components/sections/`.
 4. **eslint**, then **astro check**, then the repo's own unit tests, then
-   **astro build**.
+   **astro build**. `site-runtime verify --lint <path...>` lints those paths
+   instead of the whole repo, and `--lint` with no paths skips the lint step:
+   the runtime bump runs this gate after a mechanical rewrite, and a replica
+   carrying a lint error in a file the bump never touched would otherwise block
+   every future bump. It narrows the LINT alone, so the check, the tests and the
+   build still cover the whole repo.
 5. **bespoke siblings**: every non-draft bespoke page satisfies the two
    hydration conventions, checked against the fresh `dist/`, plus a pin on the
    Astro runtime directive contract they rely on.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iterant/site-runtime",
-  "version": "3.12.0",
+  "version": "3.13.0",
   "type": "module",
   "description": "The platform layer every Iterant brand site runs on: content grammar, collection schemas, SEO head and JSON-LD, layout core, Astro config preset, dev integrations and the verify gates.",
   "scripts": {

package/scripts/verify.mjs

@@ -32,6 +32,10 @@
  * Run from the repo root via `bun run verify` / `npm run verify` (which map to
  * `site-runtime verify`). Every path below resolves against process.cwd(), the
  * repo being verified — the gates themselves live in node_modules.
+ *
+ * One option: `--lint <path...>` lints those paths instead of the whole repo,
+ * and `--lint` with no paths skips the lint step. See the comment on the step
+ * list for why.
  */
 
 import { spawn } from "node:child_process";
@@ -234,9 +238,29 @@ if (islandProblems.length > 0) {
   exit(1);
 }
 
+// `--lint <path...>` narrows the lint step to those paths, and `--lint` with
+// none skips it. The runtime bump runs this gate in a brand sandbox after a
+// mechanical rewrite, and a replica that carries a lint error in a file the
+// bump never touched (a vendored analytics snippet, say) would otherwise block
+// every future bump on a fault the bump did not introduce. It narrows the LINT
+// alone: the check, the tests and the build still cover the whole repo, so
+// nothing the rewrite broke can hide behind it.
+const argv = process.argv.slice(2);
+const unknown = argv.find((arg) => arg.startsWith("-") && arg !== "--lint");
+if (unknown !== undefined) {
+  process.stderr.write(
+    `verify: unknown option ${unknown}; the only option is --lint <path...>\n`,
+  );
+  exit(2);
+}
+const lintIndex = argv.indexOf("--lint");
+const lintPaths = lintIndex === -1 ? ["."] : argv.slice(lintIndex + 1);
+/** @type {Array<[string, string[]]>} */
+const lintStep = lintPaths.length > 0 ? [["eslint", lintPaths]] : [];
+
 /** @type {Array<[string, string[]]>} */
 const steps = [
-  ["eslint", ["."]],
+  ...lintStep,
   ["astro", ["check"]],
   // The repo's own unit tests (bun:test). The content grammar's own suite ships
   // with this package; what runs here is whatever the brand repo keeps under

package/src/components/seo.tsx

@@ -1,3 +1,8 @@
+import {
+  HOST_SCOPE,
+  inCanonicalScope,
+  type CanonicalScope,
+} from "../lib/canonical-scope";
 import { localeFromPath } from "../lib/locales";
 import {
   SeoJson,
@@ -42,6 +47,9 @@ interface SEOProps {
   siteName?: string;
   organization?: OrganizationInfo;
   jsonLd?: SeoJsonSchema | SeoJsonSchema[];
+  /** Which paths this site's origin serves. Breadcrumb ancestors outside it
+   *  are dropped rather than linked. Defaults to the whole host. */
+  scope?: CanonicalScope;
 }
 
 export function SEO({
@@ -58,6 +66,7 @@ export function SEO({
   siteName,
   organization,
   jsonLd,
+  scope = HOST_SCOPE,
 }: SEOProps) {
   const resolvedSiteName = siteName ?? title;
   const fullTitle =
@@ -82,6 +91,7 @@ export function SEO({
         siteName: resolvedSiteName,
         organization,
         extras: jsonLd,
+        scope,
       });
 
   return (
@@ -121,6 +131,7 @@ export interface BuildGraphArgs {
   siteName: string;
   organization?: OrganizationInfo;
   extras?: SeoJsonSchema | SeoJsonSchema[];
+  scope?: CanonicalScope;
 }
 
 // Deterministic schema.org graph for every indexable page. Emitted nodes:
@@ -142,12 +153,13 @@ export function buildJsonLdGraph({
   siteName,
   organization,
   extras,
+  scope = HOST_SCOPE,
 }: BuildGraphArgs): SeoJsonSchema[] {
   const siteUrl = canonicalUrl ? new URL(canonicalUrl).origin : undefined;
   const organizationId = siteUrl ? `${siteUrl}/#organization` : undefined;
   const websiteId = siteUrl ? `${siteUrl}/#website` : undefined;
   const breadcrumb = canonicalUrl
-    ? buildBreadcrumbList({ canonicalUrl, title, siteName })
+    ? buildBreadcrumbList({ canonicalUrl, title, siteName, scope })
     : undefined;
 
   const pageNode = {
@@ -230,39 +242,58 @@ interface BreadcrumbArgs {
   canonicalUrl: string;
   title: string;
   siteName: string;
+  scope: CanonicalScope;
 }
 
 // BreadcrumbList from the canonical path. The root crumb is the site (or the
 // locale home for localized paths), intermediate crumbs are titleized
 // segments, and the last crumb is the page's own title without a link (per
-// Google's guidance the current page needs no item URL). The locale segment
-// itself is never a crumb; it only shifts where the root points. Home pages
-// (no segments) emit no breadcrumb.
+// Google's guidance the current page needs no item URL). Neither the brand
+// folder nor the locale is ever a crumb: both are platform addressing, not
+// something a reader navigated through, so they only shift where the root
+// points, to `/feed`, `/es` or `/feed/es`. Home pages (no segments) emit no
+// breadcrumb.
+//
+// An ancestor outside the canonical scope is DROPPED, not relinked (3.13.0):
+// under folder scope the site root and the locale root are the customer's own
+// homepage, and a crumb naming it would put the brand's trail on a page the
+// brand does not own. What is left can be the current page alone, which is no
+// trail at all, so that emits nothing the way a home page does.
 function buildBreadcrumbList({
   canonicalUrl,
   title,
   siteName,
+  scope,
 }: BreadcrumbArgs) {
   const url = new URL(canonicalUrl);
   const segments = url.pathname.split("/").filter(Boolean);
-  const locale = localeFromPath(url.pathname);
-  const crumbSegments = locale ? segments.slice(1) : segments;
+  const locale = localeFromPath(url.pathname, scope.folder);
+  const rootDepth =
+    (scope.folder && segments[0] === scope.folder ? 1 : 0) + (locale ? 1 : 0);
+  const crumbSegments = segments.slice(rootDepth);
   if (crumbSegments.length === 0) return undefined;
 
-  const rootPath = locale ? `/${locale}` : "/";
-  const items = [
-    { name: siteName, item: new URL(rootPath, url.origin).toString() },
-    ...crumbSegments.map((segment, index) => {
-      const isLast = index === crumbSegments.length - 1;
-      const path = `${rootPath === "/" ? "" : rootPath}/${crumbSegments
+  const rootPath = rootDepth
+    ? `/${segments.slice(0, rootDepth).join("/")}`
+    : "/";
+  const ancestors = [
+    { name: siteName, path: rootPath },
+    ...crumbSegments.slice(0, -1).map((segment, index) => ({
+      name: titleizeSegment(segment),
+      path: `${rootPath === "/" ? "" : rootPath}/${crumbSegments
         .slice(0, index + 1)
-        .join("/")}`;
-      return {
-        name: isLast ? title : titleizeSegment(segment),
-        ...(isLast ? {} : { item: new URL(path, url.origin).toString() }),
-      };
-    }),
+        .join("/")}`,
+    })),
+  ].filter((crumb) => inCanonicalScope(crumb.path, scope));
+
+  const items = [
+    ...ancestors.map((crumb) => ({
+      name: crumb.name,
+      item: new URL(crumb.path, url.origin).toString(),
+    })),
+    { name: title },
   ];
+  if (items.length < 2) return undefined;
 
   return {
     "@context": SCHEMA_CONTEXT,

package/src/config/preset.ts

@@ -12,6 +12,7 @@ import {
   fontCssVariable,
   findFontFamily,
 } from "../fonts/catalog";
+import { readCanonicalScope } from "../lib/canonical-scope";
 import { DEFAULT_CHROME_DIR, DEFAULT_PAGES_DIR } from "../lib/content-paths";
 import { assertFolder } from "../lib/folder";
 import devServerSignals from "../integrations/dev-server-signals.mjs";
@@ -220,6 +221,11 @@ export function iterantStarter({
   overrides,
 }: IterantStarterOptions = {}) {
   const siteFolder = folder === "" ? "" : assertFolder(folder);
+  // Which paths the baked `site` origin serves (3.13.0). It is a deploy
+  // decision, not a repo one: the same tree builds for the platform host and
+  // for a customer domain that forwards the folder alone, so it arrives in the
+  // environment rather than in astro.config.mjs.
+  const scope = readCanonicalScope(process.env, siteFolder);
   // A repo's own wrangler config, when it has one. The template checks in a
   // wrangler.jsonc and its compatibility_date decides how the adapter's workerd
   // prerender behaves, so passing configPath is not a detail; the lookup stays
@@ -249,13 +255,14 @@ export function iterantStarter({
     // emitted no assets at all would ENOENT here rather than skip the sitemap.
     ...sitemapWithCustomPages({
       pagesDir,
+      scope,
       ...(siteFolder && { filenameBase: `${siteFolder}/sitemap` }),
     }),
     // The folder and the site config, as a module the package's own layout and
     // routes can read. Always registered: those readers do not care whether this
     // site has a folder, and with none they read `""` and address the root.
     // With one, it also injects /<folder>/llms.txt.
-    siteModule({ folder: siteFolder, siteConfigPath }),
+    siteModule({ folder: siteFolder, scope, siteConfigPath }),
     // Dev-only: platform visual editor, gated on ?editor=1 in an iframe.
     iterantPlugins(),
     // Dev-only: swap 5xx error pages for the branded in-progress shell.

package/src/config/site-module.ts

@@ -2,21 +2,26 @@ import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import type { AstroIntegration } from "astro";
 
+import type { CanonicalScope } from "../lib/canonical-scope";
+
 // The platform's build-time facts, under a fixed module id: the brand's folder
-// as the preset was given it, and the repo's site config. A repo never imports
-// this, its own files import `@/site-config` directly; package code does,
-// because the layout, robots.txt and the injected llms.txt route all need the
-// folder and none of them is called from the config.
+// as the preset was given it, the canonical scope the deploy chose, and the
+// repo's site config. A repo never imports this, its own files import
+// `@/site-config` directly; package code does, because the layout, robots.txt
+// and the injected llms.txt route all need them and none of them is called from
+// the config.
 //
-// It is what makes the folder ONE value. The preset receives it, the assets and
-// the sitemap go under it, and every other reader takes it from here, so there
-// is no second copy for a repo to set differently.
+// It is what makes each of those ONE value. The preset receives or reads it,
+// places what it places, and every other reader takes it from here, so there is
+// no second copy for a repo to set differently.
 const SITE_ID = "virtual:iterant/site";
 const RESOLVED_SITE_ID = `\0${SITE_ID}`;
 
 export interface SiteModuleOptions {
   /** The folder, already validated. Empty means the site serves from the root. */
   folder: string;
+  /** Which paths the baked `site` origin serves, already validated. */
+  scope: CanonicalScope;
   /** The repo's site config module, relative to the project root. */
   siteConfigPath: string;
 }
@@ -34,6 +39,7 @@ export interface SiteModuleOptions {
  */
 export function siteModule({
   folder,
+  scope,
   siteConfigPath,
 }: SiteModuleOptions): AstroIntegration {
   return {
@@ -52,7 +58,10 @@ export function siteModule({
                   id === SITE_ID ? RESOLVED_SITE_ID : null,
                 load: (id: string) =>
                   id === RESOLVED_SITE_ID
-                    ? `export { SITE_CONFIG } from ${JSON.stringify(siteConfigFile)};\nexport const FOLDER = ${JSON.stringify(folder)};\n`
+                    ? `export { SITE_CONFIG } from ${JSON.stringify(siteConfigFile)};\n` +
+                      `export const FOLDER = ${JSON.stringify(folder)};\n` +
+                      `export const CANONICAL_SCOPE = ${JSON.stringify(scope.name)};\n` +
+                      `export const PLATFORM_SITE = ${JSON.stringify(scope.platformSite)};\n`
                     : null,
               },
             ],

package/src/config/virtual-modules.d.ts

@@ -13,4 +13,10 @@ declare module "virtual:iterant/site" {
   };
   /** The brand's folder, `""` when the site serves from the root. */
   export const FOLDER: string;
+  /** Which paths the baked `site` origin serves: the whole host, or the brand
+   *  folder alone on a customer domain that forwards only that prefix. */
+  export const CANONICAL_SCOPE: "host" | "folder";
+  /** The origin an out-of-scope path resolves against under `folder` scope.
+   *  Null under `host`, where every path is in scope. */
+  export const PLATFORM_SITE: string | null;
 }

package/src/index.ts

@@ -5,7 +5,8 @@
 // an Astro build (the platform agent validates brand content through it).
 //
 // Astro-bound surfaces have their own entries: `/content` (collections),
-// `/layout`, `/seo`, `/routes`, `/sitemap`, `/config`, `/integrations/*`.
+// `/layout`, `/seo`, `/routes`, `/sitemap`, `/config`, `/integrations/*`, and
+// `/hreflang`, whose `pageLocaleHead` reads the canonical scope off the preset.
 export * from "./content/schema";
 export * from "./fonts/catalog";
 export * from "./layouts/layout-core";
@@ -14,7 +15,7 @@ export * from "./lib/chrome-schemas";
 export * from "./lib/content-paths";
 export * from "./lib/content-values";
 export * from "./lib/database";
-export * from "./lib/hreflang";
+export * from "./lib/hreflang-derive";
 export * from "./lib/locales";
 export * from "./version";
 export type {

package/src/layouts/LayoutCore.astro

@@ -1,15 +1,16 @@
 ---
 import { Font, fontData } from "astro:assets";
-import { FOLDER } from "virtual:iterant/site";
+import { CANONICAL_SCOPE, FOLDER, PLATFORM_SITE } from "virtual:iterant/site";
 import { getCollection, getEntry } from "astro:content";
 import type { AstroComponentFactory } from "astro/runtime/server/index.js";
 import RelatedLinks from "../components/RelatedLinks.astro";
 import { SEO, type PageType } from "../components/seo";
 import type { SeoJsonSchema } from "../components/seo-json";
 import { fontCssVariable } from "../fonts/catalog";
+import { inCanonicalScope, originForPath } from "../lib/canonical-scope";
 import { folderPath } from "../lib/folder";
-import type { HreflangAlternate } from "../lib/hreflang";
-import { DEFAULT_LOCALE, localeFromPath } from "../lib/locales";
+import type { HreflangAlternate } from "../lib/hreflang-derive";
+import { DEFAULT_LOCALE, localeFromPath, parseEntryId } from "../lib/locales";
 import { SITE_RUNTIME_VERSION } from "../version";
 import {
   canonicalUrlFor,
@@ -103,37 +104,53 @@ const {
 
 const site = Astro.site;
 
+// Which origin this page's absolute URLs name (3.13.0). Under folder scope the
+// baked `site` is the CUSTOMER's domain, and it forwards the brand folder
+// alone: a page outside it is served on the platform's own host, so that is
+// what its canonical, og:url and og:image have to say. Under host scope this is
+// `site` for every path, byte for byte what the head carried before.
+const scope = {
+  name: CANONICAL_SCOPE,
+  folder: FOLDER,
+  platformSite: PLATFORM_SITE,
+};
+const pageOrigin = originForPath(Astro.url.pathname, scope, site);
+
 const canonicalUrl = canonicalUrlFor({
   canonical,
   pathname: Astro.url.pathname,
-  site,
+  site: pageOrigin,
+});
+const imageUrl = resolveAbsoluteUrl(image, pageOrigin);
+
+// Structured data (starter 2.17.0): resolve the current page's entry by
+// route, the same match the catch-all makes, so meta.pageType and the
+// article dates reach the JSON-LD graph without every bespoke shell having
+// to thread them. Shells that pass the props explicitly still win. Routes
+// without an entry (404, under-construction) fall back to a plain WebPage.
+const routePath = routePathFromPathname(Astro.url.pathname);
+const pageEntry = findPageEntryByRoute(await getCollection("pages"), routePath, {
+  includeDrafts: !import.meta.env.PROD,
 });
-const imageUrl = resolveAbsoluteUrl(image, site);
 
 // Site-level chrome (src/content/chrome.json). Resolved by component id so an
 // absent navbar/footer renders NO chrome — the template ships chrome.json
 // empty, so this is a byte-identical no-op until a brand populates it.
 // getEntry (not getChromeProps) because we need to distinguish an absent
 // component from empty props to drive the conditional mount.
-// Locale-aware (starter 2.8.0): a request under a locale prefix (/es/…)
-// mounts chrome.<locale>.json when that sibling exists, falling back to the
-// base chrome — pages translate before chrome does, so a missing sibling
-// must never strip the nav.
-const locale = localeFromPath(Astro.url.pathname);
+// Locale-aware (starter 2.8.0): a translated request mounts chrome.<locale>.json
+// when that sibling exists, falling back to the base chrome — pages translate
+// before chrome does, so a missing sibling must never strip the nav. The locale
+// is the page entry's OWN (`pricing.es`), so it does not depend on where the
+// locale sits in the path; a route with no entry reads the path instead.
+const locale =
+  (pageEntry ? parseEntryId(pageEntry.id).locale : undefined) ??
+  localeFromPath(Astro.url.pathname, FOLDER);
 const chromeEntry =
   (locale ? await getEntry("chrome", `chrome.${locale}`) : undefined) ??
   (await getEntry("chrome", "chrome"));
 const { navbar, footer } = pickChromeComponents(chromeEntry?.data.components);
 
-// Structured data (starter 2.17.0): resolve the current page's entry by
-// route, the same match the catch-all makes, so meta.pageType and the
-// article dates reach the JSON-LD graph without every bespoke shell having
-// to thread them. Shells that pass the props explicitly still win. Routes
-// without an entry (404, under-construction) fall back to a plain WebPage.
-const routePath = routePathFromPathname(Astro.url.pathname);
-const pageEntry = findPageEntryByRoute(await getCollection("pages"), routePath, {
-  includeDrafts: !import.meta.env.PROD,
-});
 const structuredData = resolveStructuredData(
   { pageType, datePublished, dateModified },
   pageEntry?.data.meta,
@@ -149,7 +166,13 @@ const shellId = shell ?? pageEntry?.data.shell;
 // Kept out of search, from the same entry, so the page's own noindex reaches
 // <meta robots> through a catch-all that threads nothing. A shell that passes
 // the prop wins, like shell does; no entry and no prop means indexed.
-const noindexResolved = noindex ?? pageEntry?.data.noindex ?? false;
+//
+// A page outside the canonical scope is kept out regardless (3.13.0): it is a
+// platform-only route, reachable on our host and on no customer domain, so
+// indexing it is how the same content ends up in search twice.
+const noindexResolved =
+  !inCanonicalScope(Astro.url.pathname, scope) ||
+  (noindex ?? pageEntry?.data.noindex ?? false);
 
 // Machine-fed related links (ILV-6): the machine-owned src/content/links.json
 // manifest, resolved by this page's own route key. A locale sibling looks up
@@ -244,6 +267,7 @@ const fontPreload = fonts.named ? [{ style: "normal", subset: "latin" }] : false
       siteName={siteName}
       organization={{ logo: siteConfig.logo, sameAs: siteConfig.sameAs }}
       jsonLd={jsonLd}
+      scope={scope}
     />
     {
       hreflang.map((alt) => (