@jant/core 0.6.16 → 0.7.0

package/src/routes/pages/smart-collection.tsx

@@ -0,0 +1,340 @@
+/**
+ * Smart Collection Page Route
+ *
+ * A smart collection is always public, so this file carries no page guard, no
+ * feed guard, and no "can this reader see it" branch. What it does carry is the
+ * ordinary per-post visibility floor, identical to a manual collection page:
+ * an author signed in may see more threads than an anonymous reader, on the
+ * page and in the count alike.
+ */
+
+import type { Context } from "hono";
+import type { Bindings, SmartCollection } from "../../types.js";
+import type { AppVariables } from "../../types/app-context.js";
+import { SmartCollectionPage } from "../../ui/pages/SmartCollectionPage.js";
+import { getNavigationData } from "../../lib/navigation.js";
+import { formatPageLabel, parsePageNumber } from "../../lib/pagination.js";
+import { buildPageTitle } from "../../lib/page-title.js";
+import { renderPublicPage } from "../../lib/render.js";
+import { assembleTimelineItems } from "../../lib/timeline.js";
+import { defaultFeedRenderer } from "../../lib/feed.js";
+import {
+  buildFeedDiscoveryFields,
+  getFeedEntryUpdatedAt,
+  getFeedLimit,
+  getRssPublishedBefore,
+  renderFeed,
+} from "../../lib/feed-policy.js";
+import { toPlainText as markdownToPlainText } from "../../lib/markdown.js";
+import { buildMediaMap } from "../../lib/media-helpers.js";
+import { createMediaContext, toPostViews } from "../../lib/view.js";
+import { toAbsoluteSiteUrl } from "../../lib/url.js";
+import {
+  buildSurfaceAlternates,
+  getViewLang,
+  toViewPath,
+  viewBasePath,
+} from "../../lib/view-language.js";
+import { getCollectionPagePath } from "../../lib/collection-paths.js";
+import { buildCollectionVocabulary } from "../../lib/filter-dimensions.js";
+import {
+  buildSmartCollectionArchiveHref,
+  describeSmartCollection,
+} from "../../ui/shared/smart-collection-labels.js";
+import { getI18n } from "../../i18n/index.js";
+import { SMART_COLLECTION_SORT_ORDERS } from "../../types.js";
+import type { SmartCollectionSortOrder } from "../../types.js";
+import { supportsCollectionRatingSort } from "../../lib/collection-sort.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+/**
+ * The collection vocabulary, loaded only when a condition names one.
+ *
+ * The condition line has to name the collection it filters by, and the archive
+ * link has to spell its slug — but most smart collections name none, and the
+ * lookup is a round trip.
+ */
+async function loadConditionVocabulary(
+  c: Context<Env>,
+  smartCollection: SmartCollection,
+) {
+  const ids = smartCollection.selection.collection ?? [];
+  if (ids.length === 0) return buildCollectionVocabulary([]);
+  return buildCollectionVocabulary(await c.var.services.collections.list());
+}
+
+function readSort(
+  value: string | undefined,
+  fallback: SmartCollectionSortOrder,
+  showRatingSort: boolean,
+): SmartCollectionSortOrder {
+  // `updated` was a fourth order before `newest` came to mean the same thing.
+  // Links to it are still in the wild, and they still resolve to what the
+  // reader chose, so the accept-old rule costs one line here.
+  const named = value === "updated" ? "newest" : value;
+  const requested = (
+    SMART_COLLECTION_SORT_ORDERS as readonly string[]
+  ).includes(named ?? "")
+    ? (named as SmartCollectionSortOrder)
+    : fallback;
+  // Silently falls back rather than showing an order that would look arbitrary
+  // on a set where almost nothing is rated — the same rule a collection page
+  // applies to its own rating sort.
+  return requested === "rating_desc" && !showRatingSort ? "newest" : requested;
+}
+
+/**
+ * Render a smart collection page.
+ *
+ * @param c - Hono context
+ * @param slug - The smart collection's address
+ * @returns The rendered page, or null when no smart collection lives there
+ */
+export async function renderSmartCollectionPage(
+  c: Context<Env>,
+  slug: string,
+): Promise<Response | null> {
+  const page = parsePageNumber(c.req.query("page"));
+  const paginatedPageTitle = formatPageLabel(page);
+
+  const [smartCollection, navData] = await Promise.all([
+    c.var.services.smartCollections.getBySlug(slug),
+    getNavigationData(c),
+  ]);
+  if (!smartCollection) return null;
+
+  const canonicalPagePath = getCollectionPagePath(smartCollection.slug);
+  const viewer = {
+    isAuthenticated: navData.isAuthenticated,
+    lang: getViewLang(c) ?? undefined,
+  };
+
+  // The rating order is offered only where it would say something. One cheap
+  // bounded count answers that, exactly as the collection page does it.
+  const ratedCount = await c.var.services.posts.countUpTo(
+    {
+      ...c.var.services.smartCollections.toPostFilters(smartCollection, viewer),
+      hasRating: true,
+    },
+    2,
+  );
+  const showRatingSort = supportsCollectionRatingSort(ratedCount);
+  const defaultSort = readSort(smartCollection.sort, "newest", showRatingSort);
+  // The reader's `?sort=` wins over the stored default, the same way it does on
+  // a collection page. Condition params in the URL are ignored: membership is
+  // edited in the dialog, not by hand in the address bar.
+  const currentSort = readSort(
+    c.req.query("sort"),
+    defaultSort,
+    showRatingSort,
+  );
+
+  const pageSize = c.var.appConfig.pageSize;
+  const filters = c.var.services.smartCollections.toPostFilters(
+    { ...smartCollection, sort: currentSort },
+    viewer,
+  );
+
+  const [totalThreadCount, posts, collectionVocabulary] = await Promise.all([
+    c.var.services.posts.count(filters),
+    c.var.services.posts.list({
+      ...filters,
+      limit: pageSize,
+      offset: (page - 1) * pageSize,
+    }),
+    loadConditionVocabulary(c, smartCollection),
+  ]);
+
+  const totalPages = Math.max(1, Math.ceil(totalThreadCount / pageSize));
+  const items = await assembleTimelineItems(c, posts);
+
+  const i18n = getI18n(c);
+  const dimensionCtx = { collections: collectionVocabulary };
+  const feedHref = c.var.appConfig.rssFeedsEnabled
+    ? `${canonicalPagePath}/feed`
+    : undefined;
+
+  return renderPublicPage(c, {
+    title:
+      page > 1
+        ? buildPageTitle(
+            smartCollection.title,
+            paginatedPageTitle,
+            navData.siteName,
+          )
+        : buildPageTitle(smartCollection.title, navData.siteName),
+    description: smartCollection.description
+      ? markdownToPlainText(smartCollection.description)
+      : undefined,
+    // A page the author declared, so it is always indexable and always has a
+    // canonical and an hreflang set — unlike an archive URL a reader assembled.
+    alternateLanguages: buildSurfaceAlternates(c),
+    pageFeed: feedHref
+      ? { href: toViewPath(c, feedHref), title: smartCollection.title }
+      : undefined,
+    navData,
+    content: (
+      <SmartCollectionPage
+        smartCollection={smartCollection}
+        items={items}
+        totalThreadCount={totalThreadCount}
+        currentPage={page}
+        totalPages={totalPages}
+        pagePath={canonicalPagePath}
+        baseUrl={
+          currentSort === defaultSort
+            ? toViewPath(c, canonicalPagePath)
+            : toViewPath(c, `${canonicalPagePath}?sort=${currentSort}`)
+        }
+        currentSort={currentSort}
+        defaultSort={defaultSort}
+        showRatingSort={showRatingSort}
+        conditionSummary={describeSmartCollection(
+          smartCollection.selection,
+          i18n,
+          dimensionCtx,
+        )}
+        conditionHref={buildSmartCollectionArchiveHref(
+          smartCollection.selection,
+          dimensionCtx,
+        )}
+        isAuthenticated={navData.isAuthenticated}
+        isInNavigation={navData.links.some(
+          (item) =>
+            item.type === "smart_collection" &&
+            item.smartCollectionId === smartCollection.id,
+        )}
+        sitePathPrefix={navData.sitePathPrefix}
+        basePath={navData.basePath}
+        feedHref={feedHref}
+      />
+    ),
+  });
+}
+
+/**
+ * Render a smart collection's Atom feed.
+ *
+ * No auth guard: a feed is anonymous by construction, and a smart collection
+ * can never name a set only its author can see.
+ *
+ * @param c - Hono context
+ * @param slug - The smart collection's address
+ * @returns The feed response, or null when no smart collection lives there
+ */
+export async function renderSmartCollectionFeed(
+  c: Context<Env>,
+  slug: string,
+): Promise<Response | null> {
+  const smartCollection = await c.var.services.smartCollections.getBySlug(slug);
+  if (!smartCollection) return null;
+
+  const { appConfig, services } = c.var;
+  const canonicalFeedPath = `${getCollectionPagePath(
+    smartCollection.slug,
+  )}/feed`;
+  const publishedBefore = getRssPublishedBefore(
+    appConfig.rssPublishDelaySeconds,
+  );
+
+  const filters = services.smartCollections.toPostFilters(smartCollection, {
+    isAuthenticated: false,
+    lang: getViewLang(c) ?? undefined,
+  });
+  const posts = await services.posts.list({
+    ...filters,
+    // The publication delay never moves: a just-published post is not announced
+    // early even when a year condition bounds the same column more tightly.
+    publishedBefore:
+      filters.publishedBefore === undefined
+        ? publishedBefore
+        : Math.min(filters.publishedBefore, publishedBefore),
+    limit: getFeedLimit(c),
+  });
+
+  const rootIds = posts.filter((p) => p.threadId === p.id).map((p) => p.id);
+  const postIds = posts.map((post) => post.id);
+  const [threadMap, rawMediaMap, aliasesMap] = await Promise.all([
+    services.posts.getPublishedThreads(rootIds, { publishedBefore }),
+    services.media.getByPostIds(postIds),
+    services.paths.getPostAliases(postIds),
+  ]);
+
+  const replyIds: string[] = [];
+  for (const [rootId, thread] of threadMap) {
+    for (const reply of thread) {
+      if (reply.id !== rootId) replyIds.push(reply.id);
+    }
+  }
+  const replyMediaMap =
+    replyIds.length > 0
+      ? await services.media.getByPostIds(replyIds)
+      : new Map<string, never[]>();
+
+  const mediaCtx = createMediaContext(appConfig);
+  const allRawMedia = new Map(rawMediaMap);
+  for (const [id, media] of replyMediaMap) {
+    allRawMedia.set(id, media);
+  }
+  const mediaMap = buildMediaMap(
+    allRawMedia,
+    mediaCtx.r2PublicUrl,
+    mediaCtx.imageTransformUrl,
+    mediaCtx.s3PublicUrl,
+    mediaCtx.localPublicUrl,
+    mediaCtx.sitePathPrefix,
+  );
+  const aliasMap = new Map<string, string>();
+  for (const [id, aliases] of aliasesMap) {
+    if (aliases[0]) aliasMap.set(id, aliases[0]);
+  }
+
+  const postViews = toPostViews(
+    posts.map((post) => ({
+      ...post,
+      mediaAttachments: mediaMap.get(post.id) ?? [],
+    })),
+    mediaCtx,
+    undefined,
+    aliasMap,
+  ).map((postView, index) => {
+    const post = posts[index] as (typeof posts)[number];
+    const thread = threadMap.get(post.id);
+    const replies =
+      thread && thread.length > 1
+        ? toPostViews(
+            thread
+              .filter((reply) => reply.id !== post.id)
+              .map((reply) => ({
+                ...reply,
+                mediaAttachments: mediaMap.get(reply.id) ?? [],
+              })),
+            mediaCtx,
+          )
+        : undefined;
+
+    return {
+      ...postView,
+      feedUpdatedAt: getFeedEntryUpdatedAt(post, thread),
+      threadReplies: replies,
+    };
+  });
+
+  const feedData = {
+    ...buildFeedDiscoveryFields(c),
+    siteName: appConfig.siteName,
+    siteDescription: markdownToPlainText(appConfig.siteDescription),
+    siteUrl: appConfig.siteUrl,
+    siteLanguage: getViewLang(c) ?? appConfig.siteLanguage,
+    title: buildPageTitle(appConfig.siteName, smartCollection.title),
+    selfUrl: toAbsoluteSiteUrl(
+      `${viewBasePath(c)}${canonicalFeedPath}`,
+      appConfig.siteUrl,
+      appConfig.sitePathPrefix,
+    ),
+    posts: postViews,
+  };
+
+  return renderFeed(defaultFeedRenderer(feedData));
+}

package/src/routes/pages/subscribe.tsx

@@ -0,0 +1,182 @@
+/**
+ * Subscribe Page Route
+ *
+ * `/subscribe` — how to follow this site, for a reader who does not already
+ * know. The nav's feed entry points here rather than at `/feed`, which hands a
+ * browser a screen of Atom XML.
+ *
+ * Three feeds, always, on every site: the main feed, the opposite end of the
+ * same list, and the complete record. Nothing here is conditioned on what the
+ * site happens to contain — every Jant site's subscribe page looks the same, so
+ * the page needs no service calls and no database round-trip at all.
+ *
+ * Collection feeds are deliberately absent. Wanting one collection and not the
+ * rest is a rare intent on a single-author site, and it already has a better
+ * home: the feed icon on the collection you are reading. Listing them here
+ * would tax every reader's attention for a few readers' benefit. The full route
+ * table lives in `docs/feeds.md`.
+ */
+
+import { Hono } from "hono";
+import type { Context } from "hono";
+import { msg } from "@lingui/core/macro";
+import type { Bindings } from "../../types.js";
+import type { AppVariables } from "../../types/app-context.js";
+import { getI18n } from "../../i18n/index.js";
+import { getNavigationData } from "../../lib/navigation.js";
+import { buildPageTitle } from "../../lib/page-title.js";
+import { renderPublicPage } from "../../lib/render.js";
+import { toAbsoluteSiteUrl, toPublicPath } from "../../lib/url.js";
+import {
+  buildSurfaceAlternates,
+  viewBasePath,
+} from "../../lib/view-language.js";
+import { SubscribePage } from "../../ui/pages/SubscribePage.js";
+import type { SubscribeFeed } from "../../ui/pages/SubscribePage.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const subscribeRoutes = new Hono<Env>();
+
+/**
+ * Render the subscribe page for the current view language.
+ *
+ * @param c - Hono context
+ * @returns The page, or 404 when feeds are switched off site-wide
+ */
+export async function renderSubscribePage(c: Context<Env>): Promise<Response> {
+  const { appConfig } = c.var;
+
+  // With feeds off there is nothing to subscribe to, and the nav entry is
+  // filtered out too — so the page 404s rather than listing dead addresses.
+  if (!appConfig.rssFeedsEnabled) return c.notFound();
+
+  const navData = await getNavigationData(c);
+  const i18n = getI18n(c);
+
+  // Readers paste these into a reader, so they have to be whole addresses, and
+  // they have to stay inside the language view they were read from.
+  const siteUrl =
+    appConfig.siteUrl ||
+    new URL(toPublicPath("/", appConfig.sitePathPrefix), c.req.url).toString();
+  const feedUrl = (path: string): string =>
+    toAbsoluteSiteUrl(
+      `${viewBasePath(c)}${path}`,
+      siteUrl,
+      appConfig.sitePathPrefix,
+    );
+
+  // The page each feed is the feed of. Relative, unlike the addresses: these
+  // are links to follow here and now, not strings to paste elsewhere.
+  const pageUrl = (path: string): string =>
+    toPublicPath(`${viewBasePath(c)}${path}`, appConfig.sitePathPrefix);
+
+  const latestLabel = i18n._(
+    msg({
+      message: "Latest",
+      comment: "@context: Subscribe page name for the latest public posts feed",
+    }),
+  );
+  const latestDescription = i18n._(
+    msg({
+      message: "The same posts as the home page.",
+      comment:
+        "@context: Subscribe page description of the latest posts feed. The home page and this feed run the same query, so they carry the same posts.",
+    }),
+  );
+  // `/latest` redirects to `/` — the home page is the canonical latest
+  // timeline, and its query is the one this feed runs.
+  const latestPageUrl = pageUrl("/");
+  const featuredLabel = i18n._(
+    msg({
+      message: "Featured",
+      comment: "@context: Subscribe page name for the featured posts feed",
+    }),
+  );
+  const featuredDescription = i18n._(
+    msg({
+      message: "Only the posts marked as featured.",
+      comment:
+        "@context: Subscribe page description of the featured posts feed",
+    }),
+  );
+  const featuredPageUrl = pageUrl("/featured");
+
+  const mainIsLatest = appConfig.mainRssFeed === "latest";
+
+  const mainFeed: SubscribeFeed = {
+    label: i18n._(
+      msg({
+        message: "Main feed",
+        comment: "@context: Subscribe page name for the site's main feed",
+      }),
+    ),
+    url: feedUrl("/feed"),
+    // Named for what it currently carries. `/feed` is either end of the list
+    // depending on the site's setting, and "main feed" alone says neither.
+    // The description and the page it links to are the same pair the row
+    // below uses for that feed, so the two rows can never disagree.
+    description: mainIsLatest ? latestDescription : featuredDescription,
+    pageUrl: mainIsLatest ? latestPageUrl : featuredPageUrl,
+  };
+
+  // The other end of the same list. Offering `/latest/feed` beside a `/feed`
+  // that already returns the latest posts would be two names for one feed —
+  // exactly the confusion this page exists to end. The stable aliases are an
+  // author's concern and stay in General settings and the docs.
+  const otherEnd: SubscribeFeed = mainIsLatest
+    ? {
+        label: featuredLabel,
+        url: feedUrl("/featured/feed"),
+        description: featuredDescription,
+        pageUrl: featuredPageUrl,
+      }
+    : {
+        label: latestLabel,
+        url: feedUrl("/latest/feed"),
+        description: latestDescription,
+        pageUrl: latestPageUrl,
+      };
+
+  const archiveFeed: SubscribeFeed = {
+    label: i18n._(
+      msg({
+        message: "All",
+        comment:
+          "@context: Subscribe page name for the full archive feed. Matches the Archive page's own nav label.",
+      }),
+    ),
+    url: feedUrl("/archive/feed"),
+    // Says what it adds over the others rather than sounding like the default
+    // choice, so a reader who wants everything recognizes it and a reader who
+    // wants the main line knows to skip it.
+    description: i18n._(
+      msg({
+        message:
+          "Every published post, including those kept off the home page.",
+        comment:
+          "@context: Subscribe page description of the full archive feed. Says what it adds over the other two rather than sounding like the default pick.",
+      }),
+    ),
+    pageUrl: pageUrl("/archive"),
+  };
+
+  return renderPublicPage(c, {
+    title: buildPageTitle(
+      i18n._(
+        msg({
+          message: "Subscribe",
+          comment: "@context: Browser page title for the subscribe page",
+        }),
+      ),
+      navData.siteName,
+    ),
+    alternateLanguages: buildSurfaceAlternates(c),
+    navData,
+    content: (
+      <SubscribePage mainFeed={mainFeed} otherFeeds={[otherEnd, archiveFeed]} />
+    ),
+  });
+}
+
+subscribeRoutes.get("/", renderSubscribePage);

package/src/runtime/__tests__/index.test.ts

@@ -0,0 +1,19 @@
+import { describe, it, expect } from "vitest";
+import { hasSessionCookie } from "../index.js";
+
+describe("hasSessionCookie", () => {
+  it.each([
+    ["__Secure-better-auth.session_token=abc", true],
+    ["better-auth.session_token=abc", true],
+    ["theme=dark; __Secure-better-auth.session_token=abc; lang=en", true],
+    ["theme=dark", false],
+    ["", false],
+    [null, false],
+    [undefined, false],
+    // A cookie merely *named* after the session must not count — only a value
+    // assignment does, so a stray marker cookie can't force primary reads.
+    ["mysession_token", false],
+  ])("hasSessionCookie(%s) → %s", (cookieHeader, expected) => {
+    expect(hasSessionCookie(cookieHeader)).toBe(expected);
+  });
+});

package/src/runtime/__tests__/node.test.ts

@@ -5,10 +5,15 @@ import {
 } from "../../__tests__/helpers/db.js";
 import { sqliteSchemaBundle } from "../../db/schema-bundle.js";
 import { createRequestRuntime } from "../index.js";
-import { createNodeRequestRuntime } from "../node.js";
+import { createNodeCliRuntime, createNodeRequestRuntime } from "../node.js";
+import type { CliSiteSelector } from "../site.js";
 import type { Bindings } from "../../types.js";
 import { siteDomains, sites } from "../../db/schema.js";
-import { ConflictError, NotFoundError } from "../../lib/errors.js";
+import {
+  ConflictError,
+  NotFoundError,
+  SiteUnavailableError,
+} from "../../lib/errors.js";
 import { TRANSIENT_SINGLE_SITE_ID } from "../../services/site.js";
 
 afterEach(() => {
@@ -217,7 +222,7 @@ describe("createNodeRequestRuntime", () => {
     );
   });
 
-  it("treats suspended host-based sites as not found", async () => {
+  it("treats suspended host-based sites as unavailable, not missing", async () => {
     const { db, sqlite } = createTestDatabase();
     const consoleError = vi
       .spyOn(console, "error")
@@ -250,9 +255,129 @@ describe("createNodeRequestRuntime", () => {
         } as Bindings,
         "http://suspended.localtest.me/",
       ),
-    ).rejects.toBeInstanceOf(NotFoundError);
+    ).rejects.toBeInstanceOf(SiteUnavailableError);
     expect(consoleError).toHaveBeenCalledWith(
       "[Jant] Hosted site resolution failed: host=suspended.localtest.me path=/ reason=site-not-active siteId=sit_test00000000000000000000000 siteKey=default siteStatus=suspended",
     );
   });
 });
+
+describe("createNodeCliRuntime", () => {
+  const OTHER_SITE_ID = "sit_other0000000000000000000000";
+
+  function nodeDatabaseBindings(
+    testDb: ReturnType<typeof createTestDatabase>,
+    env: Partial<Bindings> = {},
+  ): Bindings {
+    return {
+      NODE_DATABASE: {
+        db: testDb.db,
+        dialect: "sqlite",
+        rawQuery: createSqliteRawQuery(testDb.sqlite),
+        schema: sqliteSchemaBundle,
+      },
+      ...env,
+    } as Bindings;
+  }
+
+  /** The default test site plus a second tenant on its own host. */
+  function createDatabaseWithTwoSites() {
+    const testDb = createTestDatabase();
+    testDb.sqlite
+      .prepare(
+        `
+          INSERT INTO site (id, key, status, created_at, updated_at)
+          VALUES (?, 'other', 'active', 1774200001, 1774200001)
+        `,
+      )
+      .run(OTHER_SITE_ID);
+    testDb.sqlite
+      .prepare(
+        `
+          INSERT INTO site_domain (id, site_id, host, path_prefix, kind, redirect_to_primary, created_at, updated_at)
+          VALUES ('std_other_1', ?, 'other.localtest.me', NULL, 'primary', 1, 1774200001, 1774200001)
+        `,
+      )
+      .run(OTHER_SITE_ID);
+    return testDb;
+  }
+
+  // A hosted database holds every tenant, so there is no "only site" to fall
+  // back to. The single-site lookup would blame SITE_RESOLUTION_MODE, which is
+  // already host-based; the CLI has to say which flag picks the site.
+  it("requires a site selector in host-based mode with several sites", async () => {
+    const testDb = createDatabaseWithTwoSites();
+
+    await expect(
+      createNodeCliRuntime(
+        nodeDatabaseBindings(testDb, { SITE_RESOLUTION_MODE: "host-based" }),
+      ),
+    ).rejects.toThrow(
+      "host-based mode needs a target site. Pass --site <key|id>, --host <host>, or --url <url>.",
+    );
+  });
+
+  it.each<[string, CliSiteSelector]>([
+    ["key", { kind: "site", idOrKey: "other" }],
+    ["id", { kind: "site", idOrKey: OTHER_SITE_ID }],
+    ["host", { kind: "host", host: "other.localtest.me", pathPrefix: null }],
+  ])(
+    "scopes a host-based runtime to the site selected by %s",
+    async (_label, selector) => {
+      const testDb = createDatabaseWithTwoSites();
+
+      const runtime = await createNodeCliRuntime(
+        nodeDatabaseBindings(testDb, { SITE_RESOLUTION_MODE: "host-based" }),
+        selector,
+      );
+      await runtime.services.settings.set("PASSWORD_RESET_TOKEN", "hash:1");
+
+      expect(runtime.currentSite.id).toBe(OTHER_SITE_ID);
+      expect(runtime.currentSiteDomain?.host).toBe("other.localtest.me");
+      expect(
+        testDb.sqlite
+          .prepare(
+            `SELECT site_id FROM site_setting WHERE key = 'PASSWORD_RESET_TOKEN'`,
+          )
+          .pluck()
+          .all(),
+      ).toEqual([OTHER_SITE_ID]);
+    },
+  );
+
+  it("names the selector that matched no site", async () => {
+    const testDb = createDatabaseWithTwoSites();
+    const env = nodeDatabaseBindings(testDb, {
+      SITE_RESOLUTION_MODE: "host-based",
+    });
+
+    await expect(
+      createNodeCliRuntime(env, { kind: "site", idOrKey: "missing" }),
+    ).rejects.toThrow("No site found for --site missing.");
+    await expect(
+      createNodeCliRuntime(env, {
+        kind: "host",
+        host: "other.localtest.me",
+        pathPrefix: "/blog",
+      }),
+    ).rejects.toThrow(
+      'No site found for host "other.localtest.me" and path prefix "/blog".',
+    );
+  });
+
+  it("uses the instance's one site in single-site mode", async () => {
+    const runtime = await createNodeCliRuntime(
+      nodeDatabaseBindings(createTestDatabase()),
+    );
+
+    expect(runtime.currentSite.id).toBe(DEFAULT_TEST_SITE_ID);
+  });
+
+  // Here the single-site error is the accurate one: the database really does
+  // belong to a host-based install.
+  it("reports a multi-site database in single-site mode as misconfigured", async () => {
+    await expect(
+      createNodeCliRuntime(nodeDatabaseBindings(createDatabaseWithTwoSites())),
+    ).rejects.toThrow("single-site mode found multiple sites in the database:");
+  });
+});