@escape-game-over/atlas 0.1.70 → 0.1.72

package/README.md

@@ -119,6 +119,7 @@ it returns and nothing else, resolves it, and writes `_redirects`:
 // projects/rome/redirects.ts
 export default redirects([
   { from: "/jobs", to: { route: "careers" }, kind: "permanent" }, // ✗ if Rome has no careers page
+  { from: "/en/*", to: { route: "home", locale: "en-US", splat: true }, kind: "permanent" }, // /en/faq → /en-US/faq
 ])
 ```
 
@@ -194,7 +195,7 @@ than printing the brackets. See [`docs/rich-text.md`](docs/rich-text.md).
 | `LocalBusiness` JSON-LD  | `localBusiness()`                | address, phone, hours                   |
 | `Organization` JSON-LD   | `organization()`                 | name, URL, logo                         |
 | `WebSite` JSON-LD        | `website()`, home page only      | site name, optional alternate           |
-| `Product` JSON-LD        | `product()`                      | name, price table                       |
+| `Product` JSON-LD        | `product()`                      | name, price by quantity or audience     |
 | `Article` JSON-LD        | `article()`                      | headline, publication date              |
 | `VideoObject` JSON-LD    | `videoObject()`                  | a video, its stills and date            |
 | `FAQPage` JSON-LD        | `faqPage()`                      | the questions the page itself shows     |

package/docs/checks.md

@@ -116,7 +116,7 @@ dependencies at all. Vitest type-checks them itself when it runs them.
 | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `meta.test.ts`             | the `robots` tag a policy builds, the pinned `twitter:card`, share-image warnings, length warnings, `fileUrl`                                                                                        |
 | `not-found.test.ts`        | that a 404 carries the site's icon and theme colour, still names no canonical, and is held to the same icon rules                                                                                    |
-| `redirects.test.ts`        | rule resolution for all three target kinds, the five rejections, the Cloudflare 2000-rule cap                                                                                                        |
+| `redirects.test.ts`        | rule resolution for every target kind, the rejections, Cloudflare's 2000 static and 100 wildcard caps, and which rule answers a request                                                              |
 | `sitemap.test.ts`          | splitting into an index plus numbered parts, and that the entry keeps its name either way                                                                                                            |
 | `merge.test.ts`            | catalog and route overlay precedence — per locale, never per key                                                                                                                                     |
 | `llms.test.ts`             | section grouping, owners, heading and link precedence, and the undescribed fallback                                                                                                                  |
@@ -127,7 +127,7 @@ dependencies at all. Vitest type-checks them itself when it runs them.
 | `google-analytics.test.ts` | that consent is denied first and precedes every tag, one loader for many ids, dead `UA-` properties, and the preconnect — once, ahead of the block that writes the loader's URL, never `crossorigin` |
 | `contact.test.ts`          | the E.164 a `tel:` needs — trunk zero dropped, spacing stripped — and the displayed form kept                                                                                                        |
 | `hours.test.ts`            | collapsing a week into runs, week start changing the answer, and every impossible week that throws                                                                                                   |
-| `money.test.ts`            | a bare count widened to a band, the span of a table, and the gaps and overlaps that throw                                                                                                            |
+| `money.test.ts`            | a bare count widened to a band, the span of a table, the gaps and overlaps that throw, and an audience priced twice                                                                                  |
 | `url.test.ts`              | joining an origin to a path exactly once, and normalising the origin an `@id` is built from                                                                                                          |
 | `warn.test.ts`             | the shared prefix, and reducing a URL to its path                                                                                                                                                    |
 | `filters.test.ts`          | folding both sides of a query, how each kind narrows, the four URL decisions, and attach/detach                                                                                                      |

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@escape-game-over/atlas",
-    "version": "0.1.70",
+    "version": "0.1.72",
     "type": "module",
     "description": "Typed, data-driven machinery for static multi-locale, multi-deployment Astro sites.",
     "private": false,

package/src/astro/site-routes.ts

@@ -5,6 +5,7 @@ import type { AstroIntegration } from "astro";
 import type { GeneratedFile } from "../file.ts";
 import {
     buildCloudflareRedirects,
+    matchRedirect,
     type ProjectRedirects,
     type RedirectRule,
     type ResolvedRedirect,
@@ -392,21 +393,15 @@ export function siteRoutes<Id extends string, L extends string>(
                     // Not Astro's `redirects`: it serves every redirect to a
                     // non-route (an external URL, a public file) as 301,
                     // whatever status it was given.
-                    // Matched with and without a trailing slash, because a host
-                    // either normalises one away before its rules run or treats
-                    // the two as the same URL. Dev should not be the only place
-                    // where `/rooms/` misses a rule that `/rooms` hits.
-                    const canonical =
-                        path.length > 1 && path.endsWith("/")
-                            ? path.slice(0, -1)
-                            : path;
-                    const rule = redirects.find((it) => it.from === canonical);
-                    if (rule !== undefined) {
+                    // Matched as the host matches them — wildcards included,
+                    // top-most first — so `/en/faq` follows `/en/*` here too.
+                    const match = matchRedirect(redirects, path);
+                    if (match !== undefined) {
                         logger.info(
-                            `redirect: ${path} → ${rule.to} (${rule.status})`
+                            `redirect: ${path} → ${match.location} (${match.rule.status})`
                         );
-                        response.statusCode = rule.status;
-                        response.setHeader("Location", rule.to);
+                        response.statusCode = match.rule.status;
+                        response.setHeader("Location", match.location);
                         response.end();
                         return;
                     }

package/src/index.ts

@@ -196,6 +196,9 @@ export {
 // advertise a range for a room that skips sizes. `formatQuantities` answers it
 // for prose and `quantitiesFor` for structured data; both read the same tiers.
 export {
+    type AudiencePrice,
+    type AudienceTier,
+    assertAudiences,
     assertPriceTiers,
     type CurrencyCode,
     formatQuantities,

package/src/jsonld/product.ts

@@ -1,9 +1,14 @@
 import {
+    type AudiencePrice,
+    type AudienceTier,
+    assertAmount,
+    assertAudiences,
     assertPriceTiers,
     type Price,
     type PriceTier,
     type TieredPrice,
 } from "../money.ts";
+import type { NonEmpty } from "../types.ts";
 import type { HttpsUrl } from "../url.ts";
 import type { BusinessId, OrganizationId } from "./ids.ts";
 import { type JsonLdNode, schemaType } from "./node.ts";
@@ -17,7 +22,7 @@ export interface ProductInput {
     /** A picture of it, absolute. */
     readonly image?: HttpsUrl;
     /**
-     * What it costs: one price, or a price per quantity.
+     * What it costs: one price, a price per quantity, or a price per audience.
      *
      * The reason to emit this node at all — an offer with a price and a
      * currency is what a search result can show a number for. A product with no
@@ -25,9 +30,10 @@ export interface ProductInput {
      *
      * A table becomes an `AggregateOffer` carrying the range, with each band as
      * an `Offer` inside it. Two bare prices on one product would otherwise read
-     * as a contradiction rather than as a discount.
+     * as a contradiction rather than as a discount. An audience's `Offer` is
+     * named for it, so pass the words a reader sees, not the stored ids.
      */
-    readonly price: Price | TieredPrice;
+    readonly price: Price | TieredPrice | AudiencePrice;
     /**
      * The `@id` of whoever sells it — a venue, or the company itself.
      *
@@ -94,14 +100,23 @@ export function product(item: ProductInput): JsonLdNode {
 function offerFor(
     item: ProductInput,
     amount: number,
-    band?: PriceTier
+    detail: {
+        /** The quantity band this price applies at, from a `TieredPrice`. */
+        readonly band?: PriceTier;
+        /** Who pays it, from an `AudiencePrice`. */
+        readonly name?: string;
+    } = {}
 ): JsonLdNode {
-    // `currency` is on both members of the union, so no narrowing is needed;
-    // `unit` describes what a quantity counts and only a table has one.
+    const { band, name } = detail;
+    // `currency` is on every member of the union, so no narrowing is needed;
+    // `unit` describes what a quantity counts and only a quantity table has one.
     const unit = "tiers" in item.price ? item.price.unit : undefined;
 
     return {
         "@type": "Offer",
+        // An `Offer` is a `Thing`, so it can carry a `name`; it is what tells
+        // the adults' price from the children's.
+        ...(name === undefined ? {} : { name }),
         price: amount,
         priceCurrency: item.price.currency,
         availability: "https://schema.org/InStock",
@@ -131,21 +146,25 @@ function offerFor(
 /** One `Offer`, or an `AggregateOffer` wrapping the bands. */
 function offersFor(item: ProductInput): JsonLdNode {
     if ("amount" in item.price) {
+        assertAmount(item.price.amount, "product");
         return offerFor(item, item.price.amount);
     }
 
-    assertPriceTiers(item.price, "product");
+    const offers =
+        "audiences" in item.price
+            ? audienceOffers(item, item.price)
+            : tierOffers(item, item.price);
 
     // A table of one is one price, whatever it was written as. Wrapping it
     // would emit an `AggregateOffer` whose low and high are the same number
     // and whose `offerCount` is 1 — a range across nothing, and a shape that
-    // says "prices vary" of a product whose price does not. The band is still
-    // passed through, so a single row covering 2 to 6 keeps its
-    // `eligibleQuantity`: what collapses is the wrapper, not the quantity.
-    const [only, ...rest] = item.price.tiers;
-    if (rest.length === 0) return offerFor(item, only.amountPerUnit, only);
+    // says "prices vary" of a product whose price does not. The detail is
+    // kept, so a single row covering 2 to 6 keeps its `eligibleQuantity` and a
+    // single audience its name: what collapses is the wrapper, not the claim.
+    const [only, ...rest] = offers;
+    if (rest.length === 0) return only.offer;
 
-    const amounts = item.price.tiers.map((tier) => tier.amountPerUnit);
+    const amounts = offers.map((entry) => entry.amount);
 
     // The wrapper carries the *aggregate* facts and nothing else. `seller`,
     // `url` and `availability` are per-offer and sit on the bands, so a reader
@@ -164,9 +183,41 @@ function offersFor(item: ProductInput): JsonLdNode {
         // behind it. Both, because either alone is a worse answer.
         lowPrice: Math.min(...amounts),
         highPrice: Math.max(...amounts),
-        offerCount: item.price.tiers.length,
-        offers: item.price.tiers.map((tier) =>
-            offerFor(item, tier.amountPerUnit, tier)
-        ),
+        offerCount: offers.length,
+        offers: offers.map((entry) => entry.offer),
     };
 }
+
+/** One offer, and the amount it was built from, for the range. */
+interface BuiltOffer {
+    readonly amount: number;
+    readonly offer: JsonLdNode;
+}
+
+/** A quantity table's bands, each saying the quantity it applies at. */
+function tierOffers(
+    item: ProductInput,
+    price: TieredPrice
+): NonEmpty<BuiltOffer> {
+    assertPriceTiers(price, "product");
+    const build = (tier: PriceTier): BuiltOffer => ({
+        amount: tier.amountPerUnit,
+        offer: offerFor(item, tier.amountPerUnit, { band: tier }),
+    });
+    const [first, ...rest] = price.tiers;
+    return [build(first), ...rest.map(build)];
+}
+
+/** An audience table's prices, each named for who pays it. */
+function audienceOffers(
+    item: ProductInput,
+    price: AudiencePrice
+): NonEmpty<BuiltOffer> {
+    assertAudiences(price, "product");
+    const build = (tier: AudienceTier): BuiltOffer => ({
+        amount: tier.amount,
+        offer: offerFor(item, tier.amount, { name: tier.audience }),
+    });
+    const [first, ...rest] = price.audiences;
+    return [build(first), ...rest.map(build)];
+}

package/src/money.ts

@@ -242,6 +242,82 @@ export interface TieredPrice {
     readonly unit?: string;
 }
 
+/**
+ * What one kind of buyer pays.
+ *
+ * Generic over `audience` because the same price is written twice, by two
+ * different hands. Where prices are stored it is an id in the project's own
+ * vocabulary — `"adults"`, `"reduced"` — and where they are published it is the
+ * words a reader sees, since `product()` writes it as the offer's `name`. lib
+ * holds no copy, so the call site translates between the two: one shape at both
+ * ends, with the strings swapped.
+ */
+export interface AudienceTier<A extends string = string> {
+    readonly audience: A;
+    /** What one of them pays. */
+    readonly amount: number;
+}
+
+/**
+ * A price that depends on who is buying: the full rate, and less for children
+ * or students.
+ *
+ * Not a `TieredPrice`, though both are tables. That one varies with how many
+ * are bought and publishes each band as a quantity; a student rate written as a
+ * band would tell a search engine it applies to some number of players, which
+ * is a different claim and a wrong one.
+ *
+ * One currency for the table, for the reason `TieredPrice` has one.
+ */
+export interface AudiencePrice<A extends string = string> {
+    readonly currency: CurrencyCode;
+    /** The full rate first, by convention. Never empty. */
+    readonly audiences: NonEmpty<AudienceTier<A>>;
+}
+
+/**
+ * Throws on an audience table that prices one audience twice.
+ *
+ * The audience counterpart of `assertPriceTiers`, and a contradiction for the
+ * same reason an overlap is: whichever of the two a reader sees is the one they
+ * will expect to pay.
+ */
+export function assertAudiences(price: AudiencePrice, at: string): void {
+    const seen = new Set<string>();
+    const twice = new Set<string>();
+    for (const tier of price.audiences) {
+        // Published as the offer's name, so a blank one is an offer for
+        // nobody in particular — usually a translation that came back empty.
+        if (tier.audience.trim() === "") {
+            throw new Error(
+                `${at}: an audience has no name, so its price would be published unlabelled.`
+            );
+        }
+        assertAmount(tier.amount, at);
+        if (seen.has(tier.audience)) twice.add(tier.audience);
+        seen.add(tier.audience);
+    }
+    if (twice.size > 0) {
+        throw new Error(
+            `${at}: ${[...twice].map((audience) => `"${audience}"`).join(", ")} priced twice, so one buyer has two prices.`
+        );
+    }
+}
+
+/**
+ * Throws on an amount nobody can be charged: below zero, or not a number.
+ *
+ * Zero passes. Free entry for small children is a real price, and schema.org
+ * reads an offer of 0 as free rather than as missing.
+ */
+export function assertAmount(amount: number, at: string): void {
+    if (!Number.isFinite(amount) || amount < 0) {
+        throw new Error(
+            `${at}: ${amount} is not a price; an amount is zero or more.`
+        );
+    }
+}
+
 /** The band a tier covers, with a bare count widened to a range of one. */
 export function tierRange(tier: PriceTier): QuantityRange {
     return typeof tier.quantity === "number"
@@ -375,6 +451,12 @@ export function assertPriceTiers(price: TieredPrice, at: string): void {
     for (const tier of price.tiers) {
         const range = tierRange(tier);
 
+        if (!Number.isFinite(tier.amountPerUnit) || tier.amountPerUnit < 0) {
+            problems.push(
+                `${tier.amountPerUnit} is not a price; an amount is zero or more.`
+            );
+        }
+
         if (range.max < range.min) {
             problems.push(
                 `a tier covers ${range.min} to ${range.max}, which is backwards.`

package/src/redirects.ts

@@ -71,13 +71,19 @@ export type SitePath = UrlPath;
  */
 export type ExternalUrl = HttpsUrl;
 
+/** A `splat` target whose source has no `*` to carry: there is no rest to keep. */
+export interface SplatNeedsWildcard<From extends string> {
+    readonly __SPLAT_WITHOUT_WILDCARD__: `"${From}" has no "/*" to carry over: a rule with \`splat: true\` needs a source ending in "/*"`;
+}
+
 /**
- * Rejects an external target that is not `https://`, naming it.
+ * Rejects an external target that is not `https://`, and a `splat` target
+ * whose source has no wildcard, naming each.
  *
- * Applied to the rules array in parameter position, so a bad URL reports on its
- * own line rather than as the whole array failing to match. The check itself is
- * `ValidHttpsUrl`, shared with the site origin — one idea of an acceptable URL,
- * stated once.
+ * Applied to the rules array in parameter position, so a bad rule reports on
+ * its own line rather than as the whole array failing to match. The URL check
+ * itself is `ValidHttpsUrl`, shared with the site origin — one idea of an
+ * acceptable URL, stated once.
  */
 export type ValidateRedirectTargets<Rules> = {
     readonly [K in keyof Rules]: Rules[K] extends {
@@ -90,7 +96,18 @@ export type ValidateRedirectTargets<Rules> = {
                   ? ValidHttpsUrl<To>
                   : Rules[K][P];
           }
-        : Rules[K];
+        : Rules[K] extends {
+                readonly from: infer From extends string;
+                readonly to: { readonly splat: true };
+            }
+          ? From extends `${string}/*`
+              ? Rules[K]
+              : {
+                    readonly [P in keyof Rules[K]]: P extends "from"
+                        ? SplatNeedsWildcard<From>
+                        : Rules[K][P];
+                }
+          : Rules[K];
 };
 
 /**
@@ -105,7 +122,28 @@ export type ValidateRedirectTargets<Rules> = {
  */
 export type RedirectTarget<Id extends string, L extends string> =
     | ExternalUrl
-    | { readonly route: Id; readonly locale?: L; readonly page?: number }
+    | {
+          readonly route: Id;
+          readonly locale?: L;
+          readonly page?: number;
+          readonly splat?: never;
+      }
+    /**
+     * A page, with whatever the source's `*` matched kept after its path:
+     * `/en/*` to `{ route: "home", locale: "en-US", splat: true }` sends
+     * `/en/faq` to `/en-US/faq`.
+     *
+     * For an old prefix whose pages kept their slugs, so one rule answers every
+     * URL under it. The target stays a route, so the prefix it lands on is
+     * derived like every other link rather than spelled out by hand. Not with
+     * `page`: the rest of a path cannot follow a page number.
+     */
+    | {
+          readonly route: Id;
+          readonly locale?: L;
+          readonly splat: true;
+          readonly page?: never;
+      }
     /**
      * A file served verbatim from `public/` — a PDF, a spreadsheet.
      *
@@ -172,15 +210,70 @@ export interface CloudflareRedirectsOptions {
 }
 
 /**
- * Cloudflare Pages honours the first 2000 rules and drops the rest in silence.
+ * Cloudflare Pages honours 2000 static rules and 100 dynamic ones — a source
+ * with a `*` — and drops the rest in silence.
+ *
+ * Counted apart because they are capped apart: a file of 150 wildcards is far
+ * under 2100 and still loses fifty of them. Not options: they are facts about
+ * the host this renderer is named for, not preferences. Exposing them would
+ * only let a caller supply a number that is not the real one, and the failure
+ * they guard against — redirects that quietly stop working because they sit at
+ * the bottom of a long file — is exactly the kind nobody goes looking for.
+ */
+const CLOUDFLARE_STATIC_LIMIT = 2000;
+const CLOUDFLARE_DYNAMIC_LIMIT = 100;
+
+/** Whether a source matches more than itself: a `*` takes the rest of a path. */
+function isDynamic(rule: ResolvedRedirect): boolean {
+    return rule.from.includes("*");
+}
+
+/** Where a request is sent, and by which rule. */
+export interface RedirectMatch {
+    readonly rule: ResolvedRedirect;
+    /** The rule's target, with `:splat` filled in from the request. */
+    readonly location: string;
+}
+
+/**
+ * The rule a static host answers `path` with, as Cloudflare Pages picks it:
+ * the top-most rule that matches.
  *
- * Not an option: it is a fact about the host this renderer is named for, not a
- * preference. Exposing it would only let a caller supply a number that is not
- * the real one, and the failure it guards against — redirects that quietly stop
- * working because they sit at the bottom of a long file — is exactly the kind
- * nobody goes looking for.
+ * For serving the rules where no host applies them — the dev server — so a
+ * wildcard answers there as it will in production rather than only when the
+ * path is literally `/en/*`. A source ending in `/*` matches every path under
+ * it, and what the `*` took goes where the target says `:splat`; any other
+ * source matches itself, with or without a trailing slash, since a host either
+ * strips one before matching or treats the two as one URL.
+ *
+ * `path` is the path alone; a query string is the caller's to drop.
  */
-const CLOUDFLARE_RULE_LIMIT = 2000;
+export function matchRedirect(
+    rules: readonly ResolvedRedirect[],
+    path: string
+): RedirectMatch | undefined {
+    const canonical =
+        path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+    for (const rule of rules) {
+        if (rule.from.endsWith("/*")) {
+            // "/en/" from "/en/*": the bare "/en" is not under it, and every
+            // path that answers an old language has its own exact rule.
+            const prefix = rule.from.slice(0, -1);
+            if (path.startsWith(prefix)) {
+                return {
+                    rule,
+                    location: rule.to.replace(
+                        ":splat",
+                        path.slice(prefix.length)
+                    ),
+                };
+            }
+        } else if (rule.from === canonical) {
+            return { rule, location: rule.to };
+        }
+    }
+    return undefined;
+}
 
 export interface RedirectsInput {
     readonly rules: readonly ResolvedRedirect[];
@@ -271,9 +364,16 @@ export function buildCloudflareRedirects(
     redirects: readonly ResolvedRedirect[],
     options: CloudflareRedirectsOptions
 ): GeneratedFile {
-    if (redirects.length > CLOUDFLARE_RULE_LIMIT) {
+    const dynamic = redirects.filter(isDynamic).length;
+    const fixed = redirects.length - dynamic;
+    if (fixed > CLOUDFLARE_STATIC_LIMIT) {
+        throw new Error(
+            `${fixed} static redirects exceeds the ${CLOUDFLARE_STATIC_LIMIT} Cloudflare Pages honours. Everything past that would be dropped silently.`
+        );
+    }
+    if (dynamic > CLOUDFLARE_DYNAMIC_LIMIT) {
         throw new Error(
-            `${redirects.length} redirects exceeds the ${CLOUDFLARE_RULE_LIMIT} Cloudflare Pages honours. Everything past that would be dropped silently.`
+            `${dynamic} wildcard redirects exceeds the ${CLOUDFLARE_DYNAMIC_LIMIT} Cloudflare Pages honours. Everything past that would be dropped silently.`
         );
     }
 

package/src/site/create.ts

@@ -610,6 +610,20 @@ export function createSite<
             to: ((): string => {
                 if (typeof rule.to === "string") return rule.to;
                 if ("file" in rule.to) return rule.to.file;
+                if (rule.to.splat === true) {
+                    // Checked here too, for a rule the types could not see:
+                    // without a `*`, the host has nothing to put in `:splat`.
+                    if (!rule.from.endsWith("/*")) {
+                        throw new Error(
+                            `Redirect "${rule.from}" keeps the rest of the path (\`splat: true\`) but has no "/*" to take it from.`
+                        );
+                    }
+                    const path = pathFor(
+                        rule.to.route,
+                        rule.to.locale ?? defaultLocale
+                    );
+                    return path === "/" ? "/:splat" : `${path}/:splat`;
+                }
                 return pathFor(rule.to.route, rule.to.locale ?? defaultLocale, {
                     page: rule.to.page,
                 });