@escape-game-over/atlas 0.1.1 → 0.1.2

package/src/astro/element.ts

@@ -0,0 +1,259 @@
+import { reportDevError } from "./dev-log.ts";
+import { within } from "./dom.ts";
+
+/**
+ * A base for custom elements, holding the parts every one of them gets wrong.
+ *
+ * In `astro/` because it touches the DOM, which the core is type-checked
+ * without — this, `consent.ts`, `carousel.ts` and `dom.ts` are the folder
+ * allowed it.
+ *
+ * ```ts
+ * class Thing extends AtlasElement {
+ *     #count = 0;
+ *
+ *     protected setup(): void { … }        // once, ever
+ *     protected connect(): void {          // every time it enters the document
+ *         this.require("form").addEventListener("submit", this.#send, {
+ *             signal: this.signal,
+ *         });
+ *     }
+ * }
+ * customElements.define("atlas-thing", Thing);
+ * ```
+ *
+ * **Two lifetimes, and confusing them is the whole reason this class exists.**
+ * An element is constructed once and may be connected many times: moving it in
+ * the DOM runs `disconnectedCallback` then `connectedCallback` again. So
+ * `setup` is for what the element *is* — state, defaults, anything a reader
+ * would be annoyed to lose — and `connect` is for what a connection *owns* —
+ * listeners, timers, observers. Anything registered with `signal` is torn down
+ * on every disconnect and re-registered on every connect, so a re-entry rebinds
+ * rather than duplicating.
+ *
+ * **Subclasses implement `setup`, `connect` and `disconnect` — never
+ * `connectedCallback` or `disconnectedCallback`.** Overriding those replaces
+ * this class's, the controller is never created, and every listener leaks on
+ * each disconnect. `connect` is abstract, so forgetting it is a compile error;
+ * the adjacent mistake is caught at construction in development, below.
+ *
+ * **The script that defines a subclass must stay a deferred module.** Astro
+ * emits `<script>` and `<script src="./…">` as `type="module"`, which runs after
+ * the document is parsed, so an element has its children by the time it is
+ * upgraded. `is:inline` opts out and runs the script where it sits — usually
+ * above the element it wires — and every lookup then finds nothing. The
+ * protection comes from the bundling, not from custom elements.
+ *
+ * **`attributeChangedCallback` runs before `connectedCallback`** for attributes
+ * present in the initial markup, so `signal` is not available there and reading
+ * it throws. A subclass with `observedAttributes` should record what changed and
+ * act on it in `connect`.
+ *
+ * What is deliberately *not* modelled is destruction. `disconnect` fires on
+ * every move, so it is connection teardown and nothing else — it is not the
+ * place to flush state or release something genuinely scarce, because the
+ * element may well be back a microtask later.
+ */
+export abstract class AtlasElement extends HTMLElement {
+    /**
+     * Cancels this connection's listeners, and only this connection's.
+     *
+     * Remade on every connect rather than held in a field initializer, because
+     * an `AbortController` is single-use: a controller that outlived the first
+     * connection would come back already aborted, `addEventListener` with an
+     * aborted signal silently adds nothing, and the element would return looking
+     * perfectly normal and be inert forever.
+     */
+    #ac?: AbortController;
+
+    /** Whether `setup` has run. See the two-lifetimes note above. */
+    #ready = false;
+
+    constructor() {
+        super();
+        // Written as the bare expression Vite substitutes: `import.meta.env.DEV`
+        // is replaced with a literal, so this collapses to `if (false)` and the
+        // method below is dropped from the bundle. An optional chain would be
+        // replaced as `import.meta.env` instead — an object literal, whose
+        // `.DEV` a minifier has to fold rather than simply delete.
+        if (import.meta.env.DEV) this.#assertHooks();
+    }
+
+    /**
+     * Refuses a subclass that overrode the wrong lifecycle method.
+     *
+     * An override is an *own* property of the subclass prototype, where the
+     * inherited one is not — so walking up to this class's prototype finds it.
+     * The loop rather than a single check, because an intermediate base class
+     * could be the one that got it wrong.
+     */
+    #assertHooks(): void {
+        // A tuple array rather than an object: `Object.entries` widens its keys
+        // back to `string`, so the pairing would stop being checked exactly
+        // where a typo would matter.
+        const wrong = [
+            ["connectedCallback", "connect"],
+            ["disconnectedCallback", "disconnect"],
+        ] as const;
+
+        for (
+            let proto = Object.getPrototypeOf(this);
+            proto && proto !== AtlasElement.prototype;
+            proto = Object.getPrototypeOf(proto)
+        ) {
+            for (const [callback, hook] of wrong) {
+                if (Object.hasOwn(proto, callback)) {
+                    const error = new Error(
+                        `override "${hook}", not "${callback}" — see AtlasElement`
+                    );
+                    // Reported before throwing: this runs during upgrade, so
+                    // `connectedCallback`'s catch has not been entered and the
+                    // throw would surface only as an uncaught error in the
+                    // console — invisible, for the one mistake this whole
+                    // apparatus exists to catch.
+                    reportDevError(this.constructor.name, error);
+                    throw error;
+                }
+            }
+        }
+    }
+
+    /**
+     * Pass to `addEventListener`, observers, anything that should stop when the
+     * element leaves the document.
+     *
+     * Throws when read outside a connection, which is a programming error
+     * rather than a state to handle: there is nothing sensible to return.
+     */
+    protected get signal(): AbortSignal {
+        if (!this.#ac) {
+            throw new Error(
+                `${this.localName}: signal read outside a connection`
+            );
+        }
+        return this.#ac.signal;
+    }
+
+    connectedCallback(): void {
+        // Insurance. The spec pairs the callbacks, so this should never find a
+        // live controller — but if it ever did, overwriting one would orphan
+        // every listener it owned, silently, which is the failure this class
+        // exists to make impossible.
+        this.#ac?.abort();
+        this.#ac = new AbortController();
+
+        // Caught here so one broken element logs and sits inert rather than
+        // taking its siblings with it: the browser calls this once per element,
+        // so the blast radius is already one. That is what lets `require`
+        // throw instead of returning something every call site has to check.
+        try {
+            if (!this.#ready) {
+                this.setup();
+                // Only once it returned. Setting the flag first would mean a
+                // `setup` that threw was never retried, and the next connect
+                // would run `connect` against state that was never initialized
+                // — a component that renders perfectly and does nothing, which
+                // is the failure this class exists to make impossible.
+                this.#ready = true;
+            }
+            this.connect();
+        } catch (error) {
+            this.#report(error);
+        }
+    }
+
+    disconnectedCallback(): void {
+        // Idempotent, so `adoptedCallback` can delegate here without running a
+        // subclass's teardown twice.
+        if (!this.#ac) return;
+        this.#ac.abort();
+
+        // Caught for the same reason as `connect`, and it matters more: a
+        // throw here escapes into whatever is swapping the DOM — a router, a
+        // view transition — rather than staying in the component.
+        try {
+            // Before `#ac` is cleared, so `this.signal` is readable and already
+            // aborted: an async continuation can check `signal.aborted` and
+            // bail rather than finishing against a detached element.
+            this.disconnect();
+        } catch (error) {
+            this.#report(error);
+        }
+
+        this.#ac = undefined;
+    }
+
+    /**
+     * Fires when the element moves to another document.
+     *
+     * Delegates, because the controller belongs to the connection in the old
+     * document and nothing else would tear it down. Exotic — `adoptNode` and
+     * iframe work — and one line either way.
+     */
+    adoptedCallback(): void {
+        this.disconnectedCallback();
+    }
+
+    #report(error: unknown): void {
+        if (import.meta.env.DEV) {
+            reportDevError(this.localName, error);
+            return;
+        }
+        console.error(`${this.localName}:`, error);
+    }
+
+    /**
+     * Runs once per element, before its first `connect`.
+     *
+     * Where state belongs. A move re-runs `connect` but never this, so anything
+     * initialised here survives one — which is the difference between a reader
+     * coming back to the slide they left and coming back to the first one.
+     */
+    protected setup(): void {}
+
+    /** Runs on every connect, with `signal` and the children both available. */
+    protected abstract connect(): void;
+
+    /**
+     * Runs on every disconnect, once the signal has been aborted.
+     *
+     * `signal` is still readable here and reports `aborted` — which is what an
+     * async continuation should check before touching a now-detached element.
+     * What it is *not* is a destructor: a move fires this and then `connect`
+     * again a moment later, so it is connection teardown and nothing else.
+     * Flushing state or releasing something scarce does not belong here.
+     *
+     * Empty by default: anything registered with `signal` is already gone, and
+     * most elements have nothing else to undo.
+     */
+    protected disconnect(): void {}
+
+    /** The first match inside this element, or `null`. */
+    protected one<T extends Element = HTMLElement>(selector: string): T | null {
+        return within(this).one<T>(selector);
+    }
+
+    /** Every match inside this element, as an array. */
+    protected all<T extends Element = HTMLElement>(selector: string): T[] {
+        return within(this).all<T>(selector);
+    }
+
+    /**
+     * The first match, or a thrown error naming what was missing.
+     *
+     * Throws rather than returning `T | null`, because a nullable return puts an
+     * `?.` at every call site — and that optional chain swallows the failure
+     * just as thoroughly as the missing element did, which is the thing worth
+     * avoiding. `connectedCallback` catches it, so one element with broken
+     * markup logs and stops while every other element on the page is untouched.
+     */
+    protected require<T extends Element = HTMLElement>(selector: string): T {
+        const found = this.one<T>(selector);
+        if (!found) {
+            throw new Error(
+                `nothing matched "${selector}" — is the script still a deferred module?`
+            );
+        }
+        return found;
+    }
+}

package/src/astro/site-routes.ts

@@ -82,17 +82,19 @@ export interface SiteRoutesOptions {
  * Emits the files a static site owes the outside world.
  *
  * Written into the output directory when the build is done, rather than served
- * by injected routes. Two reasons, and the first is not a preference:
+ * by injected routes. One reason, and it is not the obvious one:
  *
- * - `_redirects` cannot be a page at all. Astro refuses to route anything in
- *   `src/pages` whose name begins with `_`, and URL-escaping does not help —
- *   `%5F` is decoded before the entrypoint is opened.
  * - A route is injected by *entrypoint*, and that file is compiled into the
- *   build's own module graph, where it cannot see a caller's `site`. Reaching it
- *   means naming a module in a string and resolving it through a virtual module
- *   — a lot of machinery, and nothing type-checks the string. None of these
- *   files needs the asset pipeline or a page context, so none of that buys
- *   anything.
+ *   build's own module graph, where it cannot see a caller's `site`. Every way
+ *   of reaching one from there is worse than the staleness it would cure — see
+ *   the entry in `docs/NOT-BUILT.md`, which records what was measured.
+ *
+ * **`_redirects` is not the obstacle, whatever this comment used to say.** What
+ * Astro refuses is a *filename* beginning with `_` in `src/pages`; an injected
+ * route names its pattern and its entrypoint separately, so the underscore
+ * lands only on the URL and the entrypoint is an ordinary module elsewhere.
+ * That was built and served, in dev and in a build, before being taken out
+ * again for the reason above.
  */
 export function siteRoutes(options: SiteRoutesOptions): AstroIntegration {
     const { site, redirects, llms, sitemap = true, robots = true } = options;
@@ -102,9 +104,15 @@ export function siteRoutes(options: SiteRoutesOptions): AstroIntegration {
         `${file.name} (${size(file.body)})`;
 
     // Rebuilt per request in dev and once at the end of a build, rather than
-    // computed here: in dev the site's data changes under the server, and a list
-    // captured when the integration was constructed would serve yesterday's
-    // sitemap until you restarted.
+    // computed here.
+    //
+    // Worth knowing what that does *not* buy: it does not make dev current. The
+    // `site` and the `llms` file this closes over were built when the Astro
+    // config was evaluated, and nothing re-evaluates that until the server
+    // restarts — so rebuilding per request derives the same answer from the same
+    // frozen inputs. Measured: editing a message refreshes the page that renders
+    // it and leaves the same string in `llms.txt` untouched. A build is always
+    // right, since it evaluates the config in a fresh process.
     const generate = (): GeneratedFile[] => {
         const files: GeneratedFile[] = [];
         if (sitemap) files.push(...site.sitemap().files);
@@ -143,11 +151,12 @@ export function siteRoutes(options: SiteRoutesOptions): AstroIntegration {
         name: "site-routes",
         hooks: {
             /**
-             * The three settings lib's own output would contradict, set here
-             * rather than asked for.
+             * The Astro settings this integration decides, and the one it
+             * refuses.
              *
-             * Not a preference imposed on a consumer — each is the half of a
-             * contract whose other half this library already wrote:
+             * Three are set because lib's own output would contradict them —
+             * each is the half of a contract whose other half this library
+             * already wrote:
              *
              * - `output: "static"`. Every file below is generated once, at
              *   build time, from data known then. There is no request to
@@ -167,12 +176,89 @@ export function siteRoutes(options: SiteRoutesOptions): AstroIntegration {
              *   refuse a form the host answers with a redirect rather than a
              *   404 — dev stricter than production, which teaches you nothing.
              *
-             * Set instead of validated because there is no way to tell a
-             * deliberate `"directory"` from Astro's default: both arrive here
-             * as the same resolved value, so a check could only warn at
-             * everyone or at no one.
+             * A fourth is set on weaker grounds, and deliberately so:
+             *
+             * - `prefetch`, all links, on `viewport`. Not a contract — nothing
+             *   lib emits contradicts a consumer preferring `hover` — but the
+             *   documents here are small enough that the usual objection does
+             *   not apply: every page of the larger example's 25-item grid is
+             *   around 3 kB gzipped, so prefetching the lot costs under 80 kB,
+             *   and `rel="prefetch"` fetches the HTML alone rather than its
+             *   images. A default worth overriding per site, not a rule —
+             *   though not into `prerender`; see the refusal below.
+             *
+             * Two are refused rather than set, both because Astro resolves them
+             * to a default a deliberate value is distinguishable from — so the
+             * check fires at whoever asked for it rather than at everyone:
+             *
+             * - `compressHTML: true`, which lib's output does not contradict
+             *   but its *source* does: the templates are written for Astro's
+             *   `"jsx"` whitespace rules, and `true` renders them differently.
+             * - `experimental.clientPrerender: true`, which turns the `prefetch`
+             *   above into `prerender` and runs every script on the page inside
+             *   a document nobody opened.
+             *
+             * The three contracts at the top are set instead of validated for
+             * the opposite reason: there is no way to tell a deliberate
+             * `"directory"` from Astro's default, since both arrive here as the
+             * same resolved value, so a check could only warn at everyone or at
+             * no one.
              */
-            "astro:config:setup": ({ updateConfig, logger }) => {
+            "astro:config:setup": ({
+                config: current,
+                updateConfig,
+                logger,
+            }) => {
+                /**
+                 * `compressHTML: true` is refused rather than overridden.
+                 *
+                 * Unlike the three below, this is not a setting lib's output
+                 * contradicts — both modes produce valid HTML. What it
+                 * contradicts is the *source*: every template here was written
+                 * under `"jsx"`, Astro 7's default, where whitespace around
+                 * elements is dropped and a deliberate space is written `{" "}`.
+                 * `true` keeps whitespace "as needed to maintain the visual
+                 * rendering" instead, so the same markup renders differently.
+                 *
+                 * Thrown at rather than set, because unlike `build.format` a
+                 * deliberate `true` is distinguishable from the default — so a
+                 * check can fire at exactly the person who asked for it, and
+                 * `false` stays available for reading the built HTML.
+                 */
+                if (current.compressHTML === true) {
+                    throw new Error(
+                        "compressHTML: true is not supported. The templates are written for " +
+                            'Astro\'s default "jsx" whitespace rules, where a deliberate space is `{" "}`; ' +
+                            "`true` preserves whitespace differently and renders the same markup " +
+                            'differently. Use "jsx", or `false` while inspecting the built HTML.'
+                    );
+                }
+
+                /**
+                 * `experimental.clientPrerender: true` is refused outright.
+                 *
+                 * It swaps the `rel="prefetch"` behind the default below for
+                 * speculation-rules `prerender`: the browser builds each
+                 * prefetched page in a hidden renderer and runs every script on
+                 * it for a visitor who never opened it. Umami posts a pageview,
+                 * its recorder starts a replay, and a third-party widget does
+                 * whatever it does. Gating that takes `document.prerendering`,
+                 * once per script, and a page is never done gaining scripts.
+                 *
+                 * Thrown rather than warned because none of it errors on its
+                 * own — the numbers just read high, and plausibly. `false` is
+                 * the resolved default, so this fires only at someone who
+                 * asked.
+                 */
+                if (current.experimental.clientPrerender) {
+                    throw new Error(
+                        "experimental.clientPrerender: true is not supported. It prerenders " +
+                            "prefetched pages, running every script on them — analytics and " +
+                            "third-party widgets included — for visitors who never open them. " +
+                            "Which can cause either issues or invalid metrics."
+                    );
+                }
+
                 // Annotated, not just passed: `updateConfig(config)` alone
                 // would not catch a misspelled key, because excess-property
                 // checking fires on a fresh object literal at the call site and
@@ -183,6 +269,10 @@ export function siteRoutes(options: SiteRoutesOptions): AstroIntegration {
                     output: "static",
                     build: { format: "file" },
                     trailingSlash: "ignore",
+                    prefetch: {
+                        prefetchAll: true,
+                        defaultStrategy: "viewport",
+                    },
                 };
                 updateConfig(config);
                 // Said out loud: a setting changed from under you is worth a

package/src/astro/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "extends": ["../../tsconfig.json", "astro/tsconfigs/strict"],
+    "compilerOptions": {
+        "types": ["astro/client"]
+    },
+    "include": ["**/*"],
+    "exclude": ["node_modules", "dist"]
+}

package/src/contact-form.ts

@@ -0,0 +1,177 @@
+import { type HttpsUrl, joinUrl } from "./url.ts";
+
+/**
+ * Posting a contact form to the central mail API, from the browser.
+ *
+ * The API takes the message and decides everything else: which mailbox it goes
+ * to, which template renders it, whether the sending domain is allowed at all.
+ * A form therefore never states a recipient — it states which account it is
+ * writing on behalf of, and the account owns the rest. That is what lets this
+ * ship as a static page with no server of its own.
+ *
+ * One function, and the wire format stays inside it. What a message *is* — which
+ * fields a form asks for, whether a phone number is required, how long is long
+ * enough — is a per-site decision, and the API applies its own rules regardless;
+ * checking them again here would be the same rules written twice, drifting.
+ */
+
+/**
+ * Which template renders the mail, and which mailbox it reaches.
+ *
+ * Both fall back to `default` when the type is unknown, so a typo does not lose
+ * the message — it files it as an ordinary enquiry, which is the failure worth
+ * catching. Hence a closed union rather than `string`.
+ */
+export type ContactFormType =
+    | "default"
+    | "birthday_parties"
+    | "birthday_party"
+    | "board_games"
+    | "group_booking"
+    | "team_building"
+    | "voucher";
+
+/** Where a deployment's contact mail goes. */
+export interface MailEndpoint {
+    /**
+     * The API's send route, without the account.
+     *
+     * `https` because the API reads the browser's `Origin` header and refuses
+     * anything else — see `sendContactMessage`.
+     */
+    readonly url: HttpsUrl;
+    /**
+     * The account the message is sent on behalf of: `"b2b_cube"`.
+     *
+     * What the API looks the mailbox and the allowed domains up by. A domain
+     * that is not registered against it is refused, and nothing configured here
+     * substitutes for that.
+     */
+    readonly account: string;
+    /** Defaults to `"default"`, which every account has. */
+    readonly type?: ContactFormType;
+}
+
+/** A filled-in form, in the words a page uses rather than the API's. */
+export interface ContactMessage {
+    readonly name: string;
+    readonly email: string;
+    readonly subject: string;
+    readonly message: string;
+    /**
+     * Anything else the form asked for: a phone number, a company, a date.
+     *
+     * Free-form because the API stores it as received and its template renders
+     * one titled row per entry — so `estimated_players` arrives as "Estimated
+     * Players" with no change on either side. Blanks are dropped rather than
+     * sent.
+     */
+    readonly additional?: Readonly<Record<string, string | undefined>>;
+}
+
+/**
+ * What happened to a message.
+ *
+ * Three outcomes rather than a boolean, because a form says something different
+ * about each: `rejected` is the API disagreeing and may name fields, while
+ * `unreachable` is nobody's fault and is the one worth printing an email
+ * address next to.
+ */
+export type ContactResult =
+    | { readonly ok: true }
+    | { readonly ok: false; readonly reason: "unreachable" }
+    | {
+          readonly ok: false;
+          readonly reason: "rejected";
+          /** Per field, when the API named any. Keyed as the form names them. */
+          readonly problems: Readonly<Record<string, string>>;
+      };
+
+/**
+ * The account as the API files it: lowercase, dashes as underscores, no spaces.
+ *
+ * The API normalizes what it receives, so this is not needed for a request to
+ * work — it is here so what a project writes and what the mail is filed under
+ * cannot quietly differ.
+ */
+function normalizeAccount(account: string): string {
+    return account.toLowerCase().replaceAll("-", "_").replaceAll(" ", "");
+}
+
+/** The API's field names, mapped back to the ones a form uses. */
+const FIELD_OF: Readonly<Record<string, string>> = {
+    reply_to_name: "name",
+    reply_to_email: "email",
+    subject: "subject",
+    message: "message",
+};
+
+/**
+ * Posts a message, and says what happened.
+ *
+ * **The page must be served over https.** The API reads the `Origin` header and
+ * refuses anything else before it looks at the body, so a form works on a
+ * deployed site and is rejected from `http://localhost`. Preview builds on
+ * `*.pages.dev` are recognised and routed to a development mailbox, which is
+ * the intended way to try one out.
+ *
+ * `fetch` is a parameter so this is testable without a global.
+ */
+export async function sendContactMessage(
+    endpoint: MailEndpoint,
+    message: ContactMessage,
+    fetchImpl: typeof fetch = fetch
+): Promise<ContactResult> {
+    const additional_info: Record<string, string> = {};
+    for (const [key, value] of Object.entries(message.additional ?? {})) {
+        const trimmed = value?.trim();
+        if (trimmed) additional_info[key] = trimmed;
+    }
+
+    const url = joinUrl(
+        endpoint.url,
+        `/${normalizeAccount(endpoint.account)}/${endpoint.type ?? "default"}`
+    );
+
+    let response: Response;
+    try {
+        response = await fetchImpl(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Accept: "*/*" },
+            redirect: "follow",
+            body: JSON.stringify({
+                reply_to_name: message.name.trim(),
+                reply_to_email: message.email.trim(),
+                subject: message.subject.trim(),
+                message: message.message.trim(),
+                additional_info,
+            }),
+        });
+    } catch {
+        return { ok: false, reason: "unreachable" };
+    }
+
+    if (response.ok) return { ok: true };
+
+    // The API answers a refusal with a field-keyed `problems` object, which is
+    // worth showing — but it refuses a disallowed origin or an ignored address
+    // with no fields at all, and those bodies are not always JSON. Either way
+    // the message did not send, so a parse failure is the same outcome with
+    // nothing to add.
+    try {
+        const body: unknown = await response.json();
+        const reported = (() => {
+            if (typeof body !== "object" || body === null) return undefined;
+            if (!("problems" in body)) return undefined;
+            return (body as { problems?: Record<string, string> }).problems;
+        })();
+
+        const problems: Record<string, string> = {};
+        for (const [key, value] of Object.entries(reported ?? {})) {
+            problems[FIELD_OF[key] ?? key] = value;
+        }
+        return { ok: false, reason: "rejected", problems };
+    } catch {
+        return { ok: false, reason: "rejected", problems: {} };
+    }
+}

package/src/index.ts

@@ -53,6 +53,13 @@ export {
     type PostalAddress,
     telHref,
 } from "./contact.ts";
+export {
+    type ContactFormType,
+    type ContactMessage,
+    type ContactResult,
+    type MailEndpoint,
+    sendContactMessage,
+} from "./contact-form.ts";
 export type { GeneratedFile } from "./file.ts";
 export type { PublicFilePath, PublicFileRegistry } from "./files.ts";
 export {

package/src/routes/define.ts

@@ -49,7 +49,9 @@ export interface RouteData<L extends string> {
      * `1` or omitted is an ordinary route. Above that, lib emits
      * `/news/page/2` … `/news/page/n` alongside `/news` — page one is always
      * the bare slug, never `page/1`, so there is no duplicate to canonicalise
-     * away.
+     * away. `site.redirects()` then claims `/news/page/1` with a 301 onto the
+     * bare slug, since a URL nothing publishes is still one a reader edits
+     * their way to.
      *
      * Usually set per project rather than here: the count is posts divided by
      * page size, and one venue has more posts than another.