@jant/core 0.6.16 → 0.7.0

package/src/services/search.ts

@@ -27,6 +27,13 @@ export interface SearchOptions {
   status?: Status[];
   /** Filter by format */
   format?: Format;
+  /**
+   * Restrict to one BCP 47 content language (canonical form, matched exactly).
+   *
+   * The index itself is language-agnostic — one shared index serves every
+   * language — so this is a plain residual predicate on the matched rows.
+   */
+  lang?: string;
 }
 
 export interface SearchService {
@@ -54,6 +61,8 @@ interface RawSearchRow {
   rating: number | null;
   reply_to_id: string | null;
   thread_id: string;
+  language: string | null;
+  translation_group_id: string | null;
   /** SQLite returns 0/1, Postgres a boolean. */
   quiet_reply: number | boolean | null;
   published_at: number | null;
@@ -95,6 +104,8 @@ function mapRow(row: RawSearchRow): SearchResult {
       previewProvider: null,
       replyToId: row.reply_to_id,
       threadId: row.thread_id,
+      language: row.language,
+      translationGroupId: row.translation_group_id,
       quietReply: Boolean(row.quiet_reply),
       publishedAt: row.published_at,
       lastActivityAt:
@@ -181,6 +192,8 @@ export function createSearchService(
     const statusPlaceholders = status.map(() => "?").join(", ");
     const formatFilter = options.format ? "AND post.format = ?" : "";
     const formatParams = options.format ? [options.format] : [];
+    const langFilter = options.lang ? "AND post.language = ?" : "";
+    const langParams = options.lang ? [options.lang] : [];
 
     if (databaseDialect === "sqlite") {
       const ftsQuery = buildSqliteFtsQuery(query);
@@ -204,12 +217,21 @@ export function createSearchService(
           AND post.site_id = ?
           AND post.status IN (${statusPlaceholders})
           ${formatFilter}
+          ${langFilter}
         ORDER BY post_fts.rank
         LIMIT ? OFFSET ?
       `);
 
       const { results } = await stmt
-        .bind(ftsQuery, siteId, ...status, ...formatParams, limit, offset)
+        .bind(
+          ftsQuery,
+          siteId,
+          ...status,
+          ...formatParams,
+          ...langParams,
+          limit,
+          offset,
+        )
         .all<RawSearchRow>();
 
       return withSnippetFallback((results || []).map(mapRow), query);
@@ -278,12 +300,21 @@ export function createSearchService(
         AND post.site_id = ?
         AND post.status IN (${statusPlaceholders})
         ${formatFilter}
+          ${langFilter}
       ORDER BY rank DESC, post.published_at DESC NULLS LAST, post.id DESC
       LIMIT ? OFFSET ?
     `);
 
     const { results } = await stmt
-      .bind(tsQuery, siteId, ...status, ...formatParams, limit, offset)
+      .bind(
+        tsQuery,
+        siteId,
+        ...status,
+        ...formatParams,
+        ...langParams,
+        limit,
+        offset,
+      )
       .all<RawSearchRow>();
 
     return withSnippetFallback((results || []).map(mapRow), query);
@@ -300,6 +331,8 @@ export function createSearchService(
     const statusPlaceholders = status.map(() => "?").join(", ");
     const formatFilter = options.format ? "AND post.format = ?" : "";
     const formatParams = options.format ? [options.format] : [];
+    const langFilter = options.lang ? "AND post.language = ?" : "";
+    const langParams = options.lang ? [options.lang] : [];
 
     if (databaseDialect === "pg") {
       const stmt = rawQuery.prepare(`
@@ -324,6 +357,7 @@ export function createSearchService(
           AND post.site_id = ?
           AND post.status IN (${statusPlaceholders})
           ${formatFilter}
+          ${langFilter}
         ORDER BY rank DESC, post.published_at DESC NULLS LAST, post.id DESC
         LIMIT ? OFFSET ?
       `);
@@ -338,6 +372,7 @@ export function createSearchService(
           siteId,
           ...status,
           ...formatParams,
+          ...langParams,
           limit,
           offset,
         )
@@ -371,6 +406,7 @@ export function createSearchService(
       AND post.site_id = ?
       AND post.status IN (${statusPlaceholders})
       ${formatFilter}
+          ${langFilter}
       ${likeOrderBy}
       LIMIT ? OFFSET ?
     `);
@@ -384,6 +420,7 @@ export function createSearchService(
         siteId,
         ...status,
         ...formatParams,
+        ...langParams,
         limit,
         offset,
       )

package/src/services/settings.ts

@@ -15,6 +15,7 @@ import { now } from "../lib/time.js";
 import {
   SETTINGS_KEYS,
   ONBOARDING_STATUS,
+  type OnboardingStatus,
   type SettingsKey,
 } from "../lib/constants.js";
 import {
@@ -22,8 +23,8 @@ import {
   isLocale,
   isValidContentLanguage,
   normalizeContentLanguage,
+  resolveFirstRunDashboardLocale,
 } from "../i18n/locales.js";
-import { isCjkSerifFont } from "../i18n/detect.js";
 import type { StorageDriver } from "../lib/storage.js";
 import type { MediaService } from "./media.js";
 import {
@@ -34,9 +35,49 @@ import {
 import { arrayBufferToBase64 } from "../lib/favicon.js";
 import { ValidationError } from "../lib/errors.js";
 import { normalizeEditableSettingValue } from "../lib/schemas.js";
+import { parseDiscoverSetting, type DiscoverSetting } from "../lib/discover.js";
+import {
+  sendDiscoverPing,
+  type DiscoverAnnounceOutcome,
+} from "../lib/discover-ping.js";
 import { isSupportedTimeZone, normalizeTimeZone } from "../lib/timezones.js";
 import type { FeedKind } from "../types/constants.js";
 
+/**
+ * Read a stored announcement outcome back.
+ *
+ * Tolerant on purpose: this is a settings row a person can edit or an older
+ * version can have written differently, and the worst honest answer is "no
+ * attempt recorded" — never a crashed settings page.
+ *
+ * @param raw - The stored JSON, if any
+ * @returns The outcome, or null when absent or unreadable
+ */
+function parseAnnounceState(
+  raw: string | null,
+): DiscoverAnnounceOutcome | null {
+  if (!raw) return null;
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const value = parsed as Record<string, unknown>;
+    if (typeof value["at"] !== "number") return null;
+    if (typeof value["ok"] !== "boolean") return null;
+    if (typeof value["feedUrl"] !== "string") return null;
+    return {
+      at: value["at"],
+      ok: value["ok"],
+      feedUrl: value["feedUrl"],
+      ...(typeof value["status"] === "number"
+        ? { status: value["status"] }
+        : {}),
+      ...(typeof value["error"] === "string" ? { error: value["error"] } : {}),
+    };
+  } catch {
+    return null;
+  }
+}
+
 export interface GeneralSettingsData {
   siteName: string;
   siteDescription: string;
@@ -44,7 +85,6 @@ export interface GeneralSettingsData {
   siteLanguage: string;
   /** Admin UI locale; empty string follows the content language. */
   dashboardLanguage?: string;
-  cjkSerifFont: string;
   showJantBrandingOnHome: boolean;
   mainRssFeed?: FeedKind;
   timeZone: string;
@@ -61,15 +101,23 @@ export interface SiteSettingsResult {
   siteNameChanged: boolean;
 }
 
+/**
+ * Locale fields a settings page owns.
+ *
+ * Every field is "undefined = leave untouched" so the two pages that split
+ * these settings — Language and General — can each send only what they own,
+ * without either erasing the other's field.
+ */
 export interface LocaleSettingsData {
-  siteLanguage: string;
+  /** Site content language; also the primary language when multilingual is on. */
+  siteLanguage?: string;
   /**
    * Admin dashboard UI locale. Empty string clears the explicit setting so the
    * dashboard follows the content language. When set, must be a catalog locale.
    */
   dashboardLanguage?: string;
-  cjkSerifFont: string;
-  timeZone: string;
+  /** IANA time zone; empty string resets to UTC. */
+  timeZone?: string;
 }
 
 export interface GeneralSettingsResult {
@@ -96,8 +144,27 @@ export interface SettingsService {
   set(key: SettingsKey, value: string): Promise<void>;
   setMany(entries: Partial<Record<SettingsKey, string>>): Promise<void>;
   remove(key: SettingsKey): Promise<void>;
+  /** How far first-run setup has got: pending → provisioned → completed. */
+  getOnboardingStatus(): Promise<OnboardingStatus>;
   isOnboardingComplete(): Promise<boolean>;
+  /**
+   * Mark a control-plane-created site as real but not yet confirmed by its
+   * owner. Public pages serve normally from here; setup still owes one answer.
+   */
+  markSiteProvisioned(): Promise<void>;
   completeOnboarding(): Promise<void>;
+  /**
+   * Close first-run setup on a site whose shell already exists, by recording
+   * the language its author says they write in.
+   *
+   * @param data - The confirmed content language, plus the browser's own
+   *   language so the dashboard can be pinned to it
+   * @param opts - The language in effect before this answer
+   */
+  confirmFirstRunLanguage(
+    data: { siteLanguage: string; browserLanguage?: string | null },
+    opts: { oldLanguage: string },
+  ): Promise<void>;
   updateSiteSettings(
     data: SiteSettingsData,
     opts: { fallbackSiteName: string; oldSiteName: string },
@@ -106,7 +173,6 @@ export interface SettingsService {
     data: LocaleSettingsData,
     opts: {
       oldLanguage: string;
-      oldCjkSerifFont?: string;
       oldDashboardLanguage?: string;
     },
   ): Promise<{ languageChanged: boolean }>;
@@ -116,6 +182,46 @@ export interface SettingsService {
     allowIndexing: boolean,
     opts: { demoMode: boolean },
   ): Promise<void>;
+  /**
+   * Record the site's Jant Discover choice.
+   *
+   * Always stores an explicit value, including `off`. Once someone has used
+   * this control their answer is their own, and the rule that reads `noindex`
+   * as a refusal stops applying to them.
+   *
+   * @param mode - The choice the owner just made
+   * @param opts - Demo sites never announce themselves
+   * @returns Whether this save is the moment the site opted in, and so should
+   *   announce itself to the configured directory
+   */
+  updateDiscoverSetting(
+    mode: DiscoverSetting,
+    opts: { demoMode: boolean },
+  ): Promise<{ shouldAnnounce: boolean }>;
+  /**
+   * Announce this site's feed to the configured directory, and remember how it
+   * went.
+   *
+   * The remembering is the point. An announcement that fails silently leaves
+   * the owner with a setting that reads "on" and a directory that has never
+   * heard of them, and no way to tell the two apart.
+   *
+   * Never throws: the caller runs this as background work behind a settings
+   * save, which must not fail because a directory is down.
+   *
+   * @param input - The directory endpoint and the feed address to announce
+   * @returns What the attempt came to
+   */
+  announceToDiscover(input: {
+    endpoint: string;
+    feedUrl: string;
+  }): Promise<DiscoverAnnounceOutcome>;
+  /**
+   * The last announcement attempt, or `null` if the site has never made one.
+   *
+   * @returns The stored outcome, or null when absent or unreadable
+   */
+  getDiscoverAnnounceState(): Promise<DiscoverAnnounceOutcome | null>;
   /**
    * Update general site settings with trim/set/remove logic.
    * Empty strings are removed. Default values are removed to keep the DB clean.
@@ -128,7 +234,6 @@ export interface SettingsService {
     data: GeneralSettingsData,
     opts: {
       oldLanguage: string;
-      oldCjkSerifFont?: string;
       fallbackSiteName: string;
     },
   ): Promise<GeneralSettingsResult>;
@@ -252,11 +357,29 @@ export function createSettingsService(
       });
     },
 
+    async getOnboardingStatus() {
+      const status = await this.get(SETTINGS_KEYS.ONBOARDING_STATUS);
+      if (status === ONBOARDING_STATUS.COMPLETED) {
+        return ONBOARDING_STATUS.COMPLETED;
+      }
+      if (status === ONBOARDING_STATUS.PROVISIONED) {
+        return ONBOARDING_STATUS.PROVISIONED;
+      }
+      return ONBOARDING_STATUS.PENDING;
+    },
+
     async isOnboardingComplete() {
       const status = await this.get(SETTINGS_KEYS.ONBOARDING_STATUS);
       return status === ONBOARDING_STATUS.COMPLETED;
     },
 
+    async markSiteProvisioned() {
+      await this.set(
+        SETTINGS_KEYS.ONBOARDING_STATUS,
+        ONBOARDING_STATUS.PROVISIONED,
+      );
+    },
+
     async completeOnboarding() {
       await this.set(
         SETTINGS_KEYS.ONBOARDING_STATUS,
@@ -264,6 +387,23 @@ export function createSettingsService(
       );
     },
 
+    async confirmFirstRunLanguage(data, opts) {
+      await this.updateLocaleSettings(
+        {
+          siteLanguage: data.siteLanguage,
+          // Empty means "follow the content language", which is right unless
+          // the browser named a catalog following would not reach.
+          dashboardLanguage:
+            resolveFirstRunDashboardLocale(
+              data.siteLanguage,
+              data.browserLanguage,
+            ) ?? "",
+        },
+        { oldLanguage: opts.oldLanguage },
+      );
+      await this.completeOnboarding();
+    },
+
     async updateSiteSettings(data, opts) {
       const trimmedSiteName = data.siteName.trim();
       const trimmedDescription = data.siteDescription.trim();
@@ -294,16 +434,18 @@ export function createSettingsService(
     },
 
     async updateLocaleSettings(data, opts) {
-      const trimmedLanguage = data.siteLanguage.trim() || baseLocale;
-      if (!isValidContentLanguage(trimmedLanguage)) {
-        throw new ValidationError(
-          "Enter a valid BCP 47 language tag (e.g. en, zh-Hans, fi, ja, fr-CA).",
-        );
+      let languageChanged = false;
+      if (data.siteLanguage !== undefined) {
+        const trimmedLanguage = data.siteLanguage.trim() || baseLocale;
+        if (!isValidContentLanguage(trimmedLanguage)) {
+          throw new ValidationError(
+            "Enter a valid BCP 47 language tag (e.g. en, zh-Hans, fi, ja, fr-CA).",
+          );
+        }
+        const normalized = normalizeContentLanguage(trimmedLanguage);
+        await this.set("SITE_LANGUAGE", normalized);
+        languageChanged = opts.oldLanguage !== normalized;
       }
-      await this.set(
-        "SITE_LANGUAGE",
-        normalizeContentLanguage(trimmedLanguage),
-      );
 
       // Dashboard UI locale. undefined = leave untouched; "" = clear so the
       // dashboard follows the content language; otherwise it must be one of the
@@ -325,37 +467,24 @@ export function createSettingsService(
           (opts.oldDashboardLanguage ?? "") !== dashboardLanguage;
       }
 
-      // Optional CJK fallback for content languages without a font profile.
-      const cjkFont = data.cjkSerifFont?.trim() ?? "";
-      if (cjkFont && isCjkSerifFont(cjkFont) && cjkFont !== "off") {
-        await this.set("CJK_SERIF_FONT", cjkFont);
-      } else {
-        await this.remove("CJK_SERIF_FONT");
-      }
-
-      if (data.timeZone) {
-        if (!isSupportedTimeZone(data.timeZone)) {
-          throw new ValidationError("Choose a valid time zone.");
-        }
-
-        const normalizedTimeZone = normalizeTimeZone(data.timeZone);
-        if (normalizedTimeZone !== "UTC") {
-          await this.set("TIME_ZONE", normalizedTimeZone);
+      if (data.timeZone !== undefined) {
+        if (data.timeZone) {
+          if (!isSupportedTimeZone(data.timeZone)) {
+            throw new ValidationError("Choose a valid time zone.");
+          }
+
+          const normalizedTimeZone = normalizeTimeZone(data.timeZone);
+          if (normalizedTimeZone !== "UTC") {
+            await this.set("TIME_ZONE", normalizedTimeZone);
+          } else {
+            await this.remove("TIME_ZONE");
+          }
         } else {
           await this.remove("TIME_ZONE");
         }
-      } else {
-        await this.remove("TIME_ZONE");
       }
 
-      const effectiveCjkFont =
-        cjkFont && isCjkSerifFont(cjkFont) ? cjkFont : "off";
-      return {
-        languageChanged:
-          opts.oldLanguage !== trimmedLanguage ||
-          (opts.oldCjkSerifFont ?? "off") !== effectiveCjkFont ||
-          dashboardChanged,
-      };
+      return { languageChanged: languageChanged || dashboardChanged };
     },
 
     async updateFeedSettings(data) {
@@ -384,6 +513,73 @@ export function createSettingsService(
       }
     },
 
+    async updateDiscoverSetting(mode, opts) {
+      const previous = parseDiscoverSetting(await this.get("DISCOVER"));
+      await this.set("DISCOVER", mode);
+
+      // A ping says "read me now", so both edges of this setting are worth
+      // sending one. Opting in is the obvious half — and coming from unset
+      // counts, because a site that has never touched this control has never
+      // told anyone it exists. Opting out is the half that used to be missed:
+      // a directory that is not told keeps the blog until its next scheduled
+      // read, and the owner watches a blog they just removed sit there for
+      // another hour. Switching between `latest` and `featured` while already
+      // listed changes nothing a directory needs to be told twice.
+      const wasListed = previous !== null && previous !== "off";
+      const isListed = mode !== "off";
+      const changed = wasListed !== isListed;
+      return { shouldAnnounce: changed && !opts.demoMode };
+    },
+
+    async announceToDiscover(input) {
+      const outcome = await sendDiscoverPing({
+        endpoint: input.endpoint,
+        feedUrl: input.feedUrl,
+        now,
+      });
+      // Recording is best-effort, and the try/catch is what makes the "never
+      // throws" above true. The caller runs this as background work with
+      // nothing awaiting it, so a rejection here has nobody to reject to — on
+      // a Node runtime that ends the process. A settings row that could not be
+      // written is worth a log and a status block the owner cannot read; it is
+      // not worth the site.
+      try {
+        await this.set("DISCOVER_ANNOUNCE_STATE", JSON.stringify(outcome));
+      } catch (error) {
+        // eslint-disable-next-line no-console -- The owner's status block is now stale; say why.
+        console.error(
+          `[Jant] Discover announcement could not be recorded: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+
+      // The stored outcome is for the owner, and it does not always reach
+      // them: the announcement runs behind the settings save so the response
+      // cannot carry it, and a hosted site's settings page hides the status
+      // block altogether. Log it as well, so an announcement that never got
+      // through is answerable by whoever runs the deployment — a directory
+      // pointed at the wrong host answers 404 and looks, from the dashboard,
+      // exactly like one that worked.
+      if (outcome.ok) {
+        // eslint-disable-next-line no-console -- One-line audit trail for a rare write.
+        console.log(
+          `[Jant] Discover announced: feed=${outcome.feedUrl} directory=${input.endpoint}`,
+        );
+      } else {
+        // eslint-disable-next-line no-console -- A lost announcement must be visible.
+        console.error(
+          `[Jant] Discover announcement failed: ${outcome.error ?? "Unknown error."} feed=${outcome.feedUrl} directory=${input.endpoint}`,
+        );
+      }
+
+      return outcome;
+    },
+
+    async getDiscoverAnnounceState() {
+      return parseAnnounceState(await this.get("DISCOVER_ANNOUNCE_STATE"));
+    },
+
     async updateGeneral(data, opts) {
       const { displayName } = await this.updateSiteSettings(data, {
         fallbackSiteName: opts.fallbackSiteName,
@@ -392,7 +588,6 @@ export function createSettingsService(
       await this.updateHomeBranding(data.showJantBrandingOnHome);
       const { languageChanged } = await this.updateLocaleSettings(data, {
         oldLanguage: opts.oldLanguage,
-        oldCjkSerifFont: opts.oldCjkSerifFont,
       });
 
       await this.updateFeedSettings({ mainRssFeed: data.mainRssFeed });

package/src/services/site-admin.ts

@@ -218,6 +218,7 @@ export function createSiteAdminService(
     media,
     navItems,
     pathRegistry,
+    smartCollections,
     threadCollections,
     posts,
     settings,
@@ -313,17 +314,20 @@ export function createSiteAdminService(
       databaseSchema,
       databaseDialect,
     );
-    if (await settingsService.isOnboardingComplete()) {
+    if ((await settingsService.getOnboardingStatus()) !== "pending") {
       return;
     }
 
     await settingsService.set(SETTINGS_KEYS.SITE_NAME, input.siteName);
+    // The control plane can only pass a guess — today it forwards the locale
+    // the owner was browsing it in, which is their reading language, not
+    // necessarily the one they write in. It stands in until setup asks, so the
+    // site is never languageless, and setup offers it preselected.
     await settingsService.updateLocaleSettings(
       {
         siteLanguage: input.siteLanguage?.trim()
           ? detectLocaleFromHeader(input.siteLanguage)
           : baseLocale,
-        cjkSerifFont: "off",
         timeZone: input.timeZone,
       },
       {
@@ -332,7 +336,9 @@ export function createSiteAdminService(
     );
     const navItems = createNavItemService(targetDb, siteId, databaseSchema);
     await navItems.materializeDefaultNavigation();
-    await settingsService.completeOnboarding();
+    // Not `completeOnboarding()`: the site is real and readable from here, but
+    // its owner still owes setup the one answer nothing can infer.
+    await settingsService.markSiteProvisioned();
   }
 
   async function createWithDatabase(
@@ -509,6 +515,14 @@ export function createSiteAdminService(
     );
     await targetDb.delete(posts).where(eq(posts.siteId, siteId));
 
+    // Both kinds of collection, and smart ones first — a smart collection holds
+    // a `collection_id`. There is no constraint forcing that order any more
+    // (see the note on the column in `db/schema.ts`), but this function names
+    // every table it clears, and leaving one to an implicit cascade from `site`
+    // is how the next table gets forgotten.
+    await targetDb
+      .delete(smartCollections)
+      .where(eq(smartCollections.siteId, siteId));
     await targetDb.delete(collections).where(eq(collections.siteId, siteId));
     await targetDb.delete(apiTokens).where(eq(apiTokens.siteId, siteId));
     await targetDb.delete(settings).where(eq(settings.siteId, siteId));
@@ -782,11 +796,11 @@ export function createSiteAdminService(
             (theme) => theme.id === appConfig.fontThemeId,
           )
         : undefined;
+      // The static export is one site-wide stylesheet, so it uses the site
+      // language for the CJK stack. Per-page language overrides are a runtime
+      // concern that a flat Hugo export has no equivalent for.
       const fontOverrides = {
-        ...getCjkFontCssVariables(
-          appConfig.siteLanguage,
-          appConfig.cjkSerifFont,
-        ),
+        ...getCjkFontCssVariables(appConfig.siteLanguage),
         ...(fontTheme ? getFontThemeCssVariables(fontTheme) : {}),
       };
       const themeCss = buildThemeStyle(
@@ -809,10 +823,13 @@ export function createSiteAdminService(
           siteUrl: appConfig.siteUrl,
           siteDescription: appConfig.siteDescription,
           siteLanguage: appConfig.siteLanguage,
+          multilingualEnabled: appConfig.multilingualEnabled,
+          additionalLanguages: appConfig.additionalLanguages,
           showJantBrandingOnHome: appConfig.showJantBrandingOnHome,
           publicApiEnabled: appConfig.publicApiEnabled,
           rssFeedsEnabled: appConfig.rssFeedsEnabled,
           mainRssFeed: appConfig.mainRssFeed,
+          archiveDefaultLayout: appConfig.archiveDefaultLayout,
           siteFooter: appConfig.siteFooter,
           showHeaderAvatar: appConfig.showHeaderAvatar,
           siteAvatarUrl: appConfig.siteAvatarUrl,