@jant/core 0.3.44 → 0.3.46

package/src/index.ts

@@ -82,6 +82,3 @@ export type { MediaContext } from "./lib/view.js";
 
 // Default feed renderers (for custom feed implementations)
 export { defaultFeedRenderer } from "./lib/feed.js";
-
-// GitHub Sync queue handler (for Cloudflare Workers queue consumer)
-export { handleQueueBatch as handleGitHubSyncQueueBatch } from "./lib/github-sync-queue-handler.js";

package/src/lib/__tests__/resolve-config.test.ts

@@ -307,16 +307,16 @@ describe("resolveConfig", () => {
   });
 
   it("fontThemeId falls through DB → ENV → hardcoded default", () => {
-    const c1 = resolveConfig(makeEnv({ DEFAULT_FONT_THEME: "classic" }), {
+    const c1 = resolveConfig(makeEnv({ DEFAULT_FONT_THEME: "tufte" }), {
       FONT_THEME: "geometric",
     });
     expect(c1.fontThemeId).toBe("geometric");
 
-    const c2 = resolveConfig(makeEnv({ DEFAULT_FONT_THEME: "classic" }), {});
-    expect(c2.fontThemeId).toBe("classic");
+    const c2 = resolveConfig(makeEnv({ DEFAULT_FONT_THEME: "tufte" }), {});
+    expect(c2.fontThemeId).toBe("tufte");
 
     const c3 = resolveConfig(makeEnv(), {});
-    expect(c3.fontThemeId).toBe("tufte");
+    expect(c3.fontThemeId).toBe("classic");
   });
 
   it("uses unprefixed env names across the config surface", () => {

package/src/lib/__tests__/startup-config.test.ts

@@ -16,10 +16,10 @@ const VALID_HOST_BASED_ENV = {
 };
 
 describe("getStartupConfigurationErrorPage", () => {
-  it("does not block startup when AUTH_SECRET is present", () => {
+  it("does not block startup when AUTH_SECRET is present and long enough", () => {
     expect(
       getStartupConfigurationErrorPage({
-        AUTH_SECRET: "test-secret",
+        AUTH_SECRET: "test-secret-with-enough-entropy-for-startup-checks",
         DEV_API_TOKEN: "jnt_dev_test123",
       }),
     ).toBeNull();
@@ -34,10 +34,35 @@ describe("getStartupConfigurationErrorPage", () => {
     expect(page).toContain(
       "Set <code>AUTH_SECRET=...</code> in the environment used to start Jant.",
     );
+    expect(page).toContain("openssl rand -base64 32");
     expect(page).toContain("wrangler secret put AUTH_SECRET");
     expect(page).toContain("Open configuration instructions");
   });
 
+  it("returns an error page when AUTH_SECRET is shorter than 32 characters", () => {
+    const page = getStartupConfigurationErrorPage({
+      AUTH_SECRET: "too-short",
+      DEV_API_TOKEN: "jnt_dev_test123",
+    });
+
+    expect(page).toContain("AUTH_SECRET is too short");
+    expect(page).toContain("at least 32 characters");
+    expect(page).toContain("openssl rand -base64 32");
+  });
+
+  it("returns an error page when AUTH_SECRET still uses the .env.example placeholder", () => {
+    const page = getStartupConfigurationErrorPage({
+      AUTH_SECRET: "replace-me-replace-me-replace-me-replace-me-replace-me",
+      DEV_API_TOKEN: "jnt_dev_test123",
+    });
+
+    expect(page).toContain(
+      "AUTH_SECRET is still the placeholder from .env.example",
+    );
+    expect(page).toContain("publicly known");
+    expect(page).toContain("openssl rand -base64 32");
+  });
+
   it("does not block startup when host-based required variables are present", () => {
     expect(getStartupConfigurationErrorPage(VALID_HOST_BASED_ENV)).toBeNull();
   });

package/src/lib/constants.ts

@@ -22,6 +22,7 @@ export const RESERVED_PATHS = [
   "reset",
   "collections",
   "compose",
+  "new",
   "static",
   "assets",
   "_assets",

package/src/lib/github-sync-trigger.ts

@@ -1,20 +1,14 @@
 /**
  * GitHub Sync Trigger
  *
- * Two dispatch paths:
+ * `triggerGitHubSyncInline` runs pushFullSync in the current worker
+ * invocation via `c.executionCtx.waitUntil`. Works uniformly on
+ * Workers and Node, no queue binding required.
  *
- * - `triggerGitHubSync` (queue-based): the original design, kept for
- *   future use when a Cloudflare Queue binding is actually wired up.
- *   Falls back to a no-op queue today, which silently drops jobs.
- * - `triggerGitHubSyncInline` (inline): runs pushFullSync in the
- *   current worker invocation via `c.executionCtx.waitUntil`. Works
- *   uniformly on Workers and Node, no queue binding required. This
- *   is what every caller uses today.
- *
- * Both paths debounce through a PENDING flag. When a new trigger
- * arrives while a sync is running, the inline runner records it via
- * DIRTY; the running sync re-runs once more after completion so the
- * new edits land.
+ * Debounces through a PENDING flag. When a new trigger arrives while
+ * a sync is running, the inline runner records it via DIRTY; the
+ * running sync re-runs once more after completion so the new edits
+ * land.
  */
 
 import type { Context } from "hono";
@@ -22,23 +16,10 @@ import type { SettingsService } from "../services/settings.js";
 import type { GitHubSyncService } from "../services/github-sync.js";
 import type { AppVariables } from "../types/app-context.js";
 import type { Bindings } from "../types/bindings.js";
-import { noopQueue, type JobQueue } from "./job-queue.js";
-import { createCfJobQueue } from "./job-queue-cf.js";
 import { buildSyncSiteConfig } from "./github-sync-site-config.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
-/**
- * Resolve the appropriate job queue from the environment.
- * Returns the CF Queue adapter if available, otherwise noop.
- */
-export function resolveJobQueue(env: { GITHUB_SYNC_QUEUE?: Queue }): JobQueue {
-  if (env.GITHUB_SYNC_QUEUE) {
-    return createCfJobQueue(env.GITHUB_SYNC_QUEUE);
-  }
-  return noopQueue;
-}
-
 /**
  * Maximum time a sync is allowed to be "in flight" before we consider
  * the PENDING flag stale. Covers worker crashes, timeouts, and any
@@ -89,31 +70,6 @@ export async function markSyncPending(
   await settings.set("GITHUB_SYNC_DIRTY", "");
 }
 
-/**
- * Queue-based trigger. Safe to call on every post mutation. Kept for
- * compatibility with the original design but currently enqueues to a
- * noop queue on every known deployment — callers should use
- * `triggerGitHubSyncInline` instead.
- */
-export async function triggerGitHubSync(
-  queue: JobQueue,
-  settings: SettingsService,
-  siteId: string,
-): Promise<void> {
-  const enabled = await settings.get("GITHUB_SYNC_ENABLED");
-  if (enabled !== "true") return;
-
-  const alreadyPending = await settings.get("GITHUB_SYNC_PENDING");
-  if (alreadyPending === "true") return;
-
-  await settings.set("GITHUB_SYNC_PENDING", "true");
-  await queue.enqueue({
-    kind: "github-sync-push",
-    siteId,
-    data: {},
-  });
-}
-
 /**
  * Run a full GitHub Sync push in the background, managing the lifecycle
  * flags (`GITHUB_SYNC_PENDING`, `GITHUB_SYNC_DIRTY`, `GITHUB_SYNC_LAST_ERROR`).

package/src/lib/startup-config.ts

@@ -12,6 +12,40 @@ import {
 import type { Bindings } from "../types.js";
 
 const HOSTED_SHARED_SECRET_MIN_LENGTH = 32;
+export const AUTH_SECRET_MIN_LENGTH = 32;
+
+const AUTH_SECRET_GENERATION_HINT =
+  "Generate one with `openssl rand -base64 32`.";
+
+const AUTH_SECRET_PLACEHOLDER_MARKER = "replace-me";
+
+type AuthSecretIssueKind = "missing" | "placeholder" | "too-short";
+
+export function getAuthSecretIssueKind(
+  env: Pick<Bindings, "AUTH_SECRET">,
+): AuthSecretIssueKind | null {
+  const secret = getAuthSecret(env);
+  if (!secret) {
+    return "missing";
+  }
+  if (secret.toLowerCase().includes(AUTH_SECRET_PLACEHOLDER_MARKER)) {
+    return "placeholder";
+  }
+  if (secret.length < AUTH_SECRET_MIN_LENGTH) {
+    return "too-short";
+  }
+  return null;
+}
+
+export function getAuthSecretReadinessError(kind: AuthSecretIssueKind): string {
+  if (kind === "placeholder") {
+    return `AUTH_SECRET still uses the placeholder value from .env.example. ${AUTH_SECRET_GENERATION_HINT}`;
+  }
+  if (kind === "too-short") {
+    return `AUTH_SECRET must be at least ${AUTH_SECRET_MIN_LENGTH} characters before Jant can accept traffic. ${AUTH_SECRET_GENERATION_HINT}`;
+  }
+  return "AUTH_SECRET must be set before Jant can accept traffic.";
+}
 
 interface StartupConfigurationIssue {
   message: string;
@@ -41,13 +75,25 @@ ${input.bodyHtml}
 </html>`;
 }
 
-function getAuthSecretErrorHtml(): string {
-  const runtimeInstructions = `<p>Set <code>AUTH_SECRET=...</code> in the environment used to start Jant.</p>
+function getAuthSecretErrorHtml(kind: AuthSecretIssueKind): string {
+  const runtimeInstructions = `<p>Set <code>AUTH_SECRET=...</code> in the environment used to start Jant. Generate one with <code>openssl rand -base64 32</code>.</p>
 <p><strong>Cloudflare Workers:</strong> add <code>AUTH_SECRET</code> as a Worker secret in the dashboard under Variables and Secrets, or run <code>wrangler secret put AUTH_SECRET</code>.</p>`;
 
+  const titleByKind: Record<AuthSecretIssueKind, string> = {
+    missing: "AUTH_SECRET is not set",
+    placeholder: "AUTH_SECRET is still the placeholder from .env.example",
+    "too-short": `AUTH_SECRET is too short (must be at least ${AUTH_SECRET_MIN_LENGTH} characters)`,
+  };
+
+  const leadByKind: Record<AuthSecretIssueKind, string> = {
+    missing: `<p>Jant needs a ${AUTH_SECRET_MIN_LENGTH}+ character auth secret to sign sessions.</p>`,
+    placeholder: `<p>The current <code>AUTH_SECRET</code> still contains the <code>replace-me</code> placeholder from <code>.env.example</code>. This value is publicly known and unsafe to use; replace it with a real secret before serving traffic.</p>`,
+    "too-short": `<p>Jant needs an auth secret of at least ${AUTH_SECRET_MIN_LENGTH} characters to sign sessions. The current value is too short.</p>`,
+  };
+
   return renderConfigurationErrorPage({
-    title: "AUTH_SECRET is not set",
-    bodyHtml: `<p>Jant needs a 32+ character auth secret to sign sessions.</p>${runtimeInstructions}`,
+    title: titleByKind[kind],
+    bodyHtml: `${leadByKind[kind]}${runtimeInstructions}`,
     docsHref:
       "https://github.com/jant-me/jant/blob/main/docs/configuration.md#required",
   });
@@ -231,8 +277,9 @@ export function getStartupConfigurationErrorPage(
     | "SITE_RESOLUTION_MODE"
   >,
 ): string | null {
-  if (!getAuthSecret(env)) {
-    return getAuthSecretErrorHtml();
+  const authSecretIssue = getAuthSecretIssueKind(env);
+  if (authSecretIssue) {
+    return getAuthSecretErrorHtml(authSecretIssue);
   }
 
   const hostBasedIssues = collectHostBasedStartupConfigurationIssues(env);

package/src/routes/api/github-sync.tsx

@@ -10,8 +10,8 @@ import { z } from "zod";
 import type { Bindings } from "../../types.js";
 import type { AppVariables } from "../../types/app-context.js";
 import { requireAuthApi } from "../../middleware/auth.js";
+import { withConfig } from "../../middleware/config.js";
 import { verifyGitHubWebhookSignature } from "../../lib/webhook-signature.js";
-import { resolveJobQueue } from "../../lib/github-sync-trigger.js";
 import { createGitHubClient, parseRepoSlug } from "../../lib/github-api.js";
 import {
   createGitHubSyncService,
@@ -36,7 +36,12 @@ type Env = { Bindings: Bindings; Variables: AppVariables };
 
 export const githubSyncWebhookRoutes = new Hono<Env>();
 
-githubSyncWebhookRoutes.post("/webhook", async (c) => {
+// `withConfig` here loads `appConfig`/`allSettings`/`themeStyle` for
+// `buildSyncSiteConfig`. The webhook subrouter is mounted before the
+// global `withConfig` middleware (it must skip auth/onboarding), so we
+// apply it route-locally rather than per-subrouter — the sibling
+// `/app-webhook` is host-agnostic and doesn't need site config.
+githubSyncWebhookRoutes.post("/webhook", withConfig(), async (c) => {
   // Prefer an app-level webhook secret when configured (GitHub App deployments
   // can set a single shared secret on the App and skip per-site secrets);
   // otherwise fall back to the per-site secret saved during setup.
@@ -72,18 +77,35 @@ githubSyncWebhookRoutes.post("/webhook", async (c) => {
     return c.json({ ok: true, skipped: "jant-sync commits" });
   }
 
-  // Enqueue pull job
-  const queue = resolveJobQueue(c.env);
-  await queue.enqueue({
-    kind: "github-sync-pull",
-    siteId: c.var.currentSite.id,
-    data: {
-      ref: payload.ref,
-      before: payload.before,
-      after: payload.after,
-      commits: payload.commits,
-    },
-  });
+  // Run the pull inline. Self-hosted Node deployments don't have a
+  // CF Queue binding, and the legacy queue path silently dropped jobs
+  // through `noopQueue`. Mirroring `triggerGitHubSyncInline`, we hand
+  // the work to `executionCtx.waitUntil` so the HTTP response returns
+  // immediately while the sync runs in the background.
+  const syncService = createGitHubSyncService(
+    c.var.services,
+    c.var.currentSite.id,
+    await buildSyncSiteConfig(c),
+    { storage: c.var.storage, githubApp: getGitHubAppConfig(c.env) },
+  );
+
+  const settings = c.var.services.settings;
+  const run = (async () => {
+    try {
+      await syncService.handleWebhookPush(payload);
+      await settings.set("GITHUB_SYNC_LAST_ERROR", "");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      await settings.set("GITHUB_SYNC_LAST_ERROR", message);
+    }
+  })();
+
+  try {
+    c.executionCtx?.waitUntil(run);
+  } catch {
+    // executionCtx not available (e.g. tests) — promise still resolves
+    // on its own; HTTP response returns immediately either way.
+  }
 
   return c.json({ ok: true, queued: true });
 });

package/src/routes/pages/home.tsx

@@ -104,6 +104,8 @@ homeRoutes.get("/", async (c) => {
         baseUrl={toPublicPath("/", navData.sitePathPrefix)}
         currentPage={currentPage}
         totalPages={totalPages}
+        isAuthenticated={isAuthenticated}
+        signinUrl={`${toPublicPath("/signin", navData.sitePathPrefix)}?redirect=${encodeURIComponent(toPublicPath("/", navData.sitePathPrefix))}`}
       />
     ),
   });

package/src/routes/pages/latest.tsx

@@ -59,6 +59,8 @@ latestRoutes.get("/", async (c) => {
         baseUrl={toPublicPath("/latest", navData.sitePathPrefix)}
         currentPage={currentPage}
         totalPages={totalPages}
+        isAuthenticated={navData.isAuthenticated}
+        signinUrl={`${toPublicPath("/signin", navData.sitePathPrefix)}?redirect=${encodeURIComponent(toPublicPath("/latest", navData.sitePathPrefix))}`}
       />
     ),
   });

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

@@ -50,6 +50,40 @@ describe("getInstanceReadiness", () => {
     });
   });
 
+  it("reports startup configuration failures when AUTH_SECRET is too short", async () => {
+    const { sqlite } = createTestDatabase();
+
+    const result = await getInstanceReadiness({
+      AUTH_SECRET: "too-short",
+      NODE_SQLITE: sqlite,
+    });
+
+    expect(result.status).toBe("error");
+    expect(result.checks.database).toEqual({ ok: true });
+    expect(result.checks.startupConfig.ok).toBe(false);
+    expect(result.checks.startupConfig.error).toContain(
+      "AUTH_SECRET must be at least 32 characters",
+    );
+    expect(result.checks.startupConfig.error).toContain(
+      "openssl rand -base64 32",
+    );
+  });
+
+  it("reports startup configuration failures when AUTH_SECRET is still the placeholder", async () => {
+    const { sqlite } = createTestDatabase();
+
+    const result = await getInstanceReadiness({
+      AUTH_SECRET: "replace-me-replace-me-replace-me-replace-me-replace-me",
+      NODE_SQLITE: sqlite,
+    });
+
+    expect(result.status).toBe("error");
+    expect(result.checks.startupConfig.ok).toBe(false);
+    expect(result.checks.startupConfig.error).toContain(
+      "AUTH_SECRET still uses the placeholder value from .env.example",
+    );
+  });
+
   it("reports host-based startup issues when required env is missing", async () => {
     const { sqlite } = createTestDatabase();
 

package/src/runtime/readiness.ts

@@ -1,7 +1,10 @@
 import { createDatabase, createNodeDatabase } from "../db/index.js";
 import { sqliteSchemaBundle } from "../db/schema-bundle.js";
-import { getAuthSecret } from "../lib/env.js";
-import { getHostBasedStartupConfigurationIssues } from "../lib/startup-config.js";
+import {
+  getAuthSecretIssueKind,
+  getAuthSecretReadinessError,
+  getHostBasedStartupConfigurationIssues,
+} from "../lib/startup-config.js";
 import { createSiteService } from "../services/site.js";
 import type { Bindings } from "../types/bindings.js";
 
@@ -33,8 +36,9 @@ function getStartupConfigurationReadiness(
 ): ReadinessCheckStatus {
   const errors: string[] = [];
 
-  if (!getAuthSecret(env)) {
-    errors.push("AUTH_SECRET must be set before Jant can accept traffic.");
+  const authSecretIssue = getAuthSecretIssueKind(env);
+  if (authSecretIssue) {
+    errors.push(getAuthSecretReadinessError(authSecretIssue));
   }
 
   for (const issue of getHostBasedStartupConfigurationIssues(env)) {

package/src/services/__tests__/collection.test.ts

@@ -127,25 +127,27 @@ describe("CollectionService", () => {
       ).rejects.toThrow("Use lowercase letters, numbers, and hyphens only.");
     });
 
-    it("allows root-level slugs that only conflicted in the old namespace", async () => {
+    it("allows valid non-reserved collection slugs", async () => {
       await expect(
         collectionService.create({
-          slug: "new",
-          title: "New",
+          slug: "favorites",
+          title: "Favorites",
         }),
       ).resolves.toMatchObject({
-        slug: "new",
-        title: "New",
+        slug: "favorites",
+        title: "Favorites",
       });
     });
 
     it("rejects slugs reserved by top-level routes", async () => {
-      await expect(
-        collectionService.create({
-          slug: "collections",
-          title: "Collections",
-        }),
-      ).rejects.toThrow("This link is reserved. Choose something else.");
+      for (const slug of ["collections", "new", "compose"]) {
+        await expect(
+          collectionService.create({
+            slug,
+            title: slug,
+          }),
+        ).rejects.toThrow("This link is reserved. Choose something else.");
+      }
     });
   });
 

package/src/services/github-sync.ts

@@ -651,9 +651,15 @@ export function createGitHubSyncService(
         if (frontMatter.link_url !== undefined) {
           updateData.url = frontMatter.link_url;
         }
+        if (frontMatter.source_name !== undefined)
+          updateData.sourceName = frontMatter.source_name;
+        if (frontMatter.source_url !== undefined)
+          updateData.sourceUrl = frontMatter.source_url;
         if (frontMatter.quote_text !== undefined) {
           updateData.quoteText = frontMatter.quote_text;
         }
+        if (frontMatter.rating !== undefined)
+          updateData.rating = frontMatter.rating;
 
         if (Object.keys(updateData).length > 0) {
           await services.posts.update(existingPost.id, updateData);

package/src/styles/components.css

@@ -106,6 +106,20 @@ svg[stroke-width].icon-fine {
     }
   }
 
+  .toast-copy {
+    @apply shrink-0 translate-y-0.5 cursor-pointer rounded-sm p-0 border-0 bg-transparent;
+    color: var(--color-muted-foreground);
+    transition: color 0.15s;
+
+    &:hover {
+      color: var(--color-foreground);
+    }
+
+    > svg {
+      @apply size-3.5;
+    }
+  }
+
   .toast-out {
     animation: toast-out 0.3s ease-in forwards;
   }

package/src/styles/ui.css

@@ -5796,6 +5796,87 @@
     min-width: 0;
   }
 
+  .compose-quick-actions-row {
+    display: flex;
+    justify-content: flex-end;
+    padding: 2px 12px 12px;
+    background-color: var(--compose-paper-bg);
+  }
+
+  .compose-action-row:has(+ .compose-quick-actions-row) {
+    padding-bottom: 4px;
+  }
+
+  @media (min-width: 700px) {
+    .compose-quick-actions-row {
+      padding: 2px 18px 14px;
+    }
+
+    .compose-action-row:has(+ .compose-quick-actions-row) {
+      padding-bottom: 4px;
+    }
+  }
+
+  .compose-publish-quick-toggle {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.4rem;
+    padding: 0.5rem 0.55rem;
+    margin: 0 -0.4rem;
+    min-height: 36px;
+    font-size: var(--type-ui-caption);
+    color: color-mix(in srgb, var(--site-text-secondary) 78%, transparent);
+    cursor: pointer;
+    user-select: none;
+    line-height: 1.1;
+    border-radius: 6px;
+    -webkit-tap-highlight-color: transparent;
+    transition:
+      color 0.15s ease,
+      background-color 0.15s ease;
+  }
+
+  .compose-publish-quick-toggle:active {
+    background-color: color-mix(
+      in srgb,
+      var(--site-text-primary) 6%,
+      transparent
+    );
+  }
+
+  @media (min-width: 700px) {
+    .compose-publish-quick-toggle {
+      padding: 0.3rem 0.35rem;
+      margin: 0 -0.2rem;
+      min-height: 0;
+    }
+  }
+
+  .compose-publish-quick-toggle:hover {
+    color: var(--site-text-secondary);
+  }
+
+  .compose-publish-quick-toggle:has(input:checked) {
+    color: color-mix(in srgb, var(--site-text-primary) 85%, transparent);
+  }
+
+  .compose-publish-quick-toggle-input {
+    width: 0.88rem !important;
+    height: 0.88rem !important;
+    border-radius: 3px;
+  }
+
+  .compose-publish-quick-toggle-input:checked:after {
+    width: 0.74rem !important;
+    height: 0.74rem !important;
+    mask-size: 0.74rem !important;
+  }
+
+  .compose-publish-quick-toggle:has(input:disabled) {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
   .compose-publish-summaries {
     display: flex;
     flex-wrap: wrap;
@@ -6838,6 +6919,9 @@
     border: none;
     padding: 8px;
     transition: background-color 0.15s;
+    flex-direction: column;
+    justify-content: center;
+    gap: 6px;
   }
 
   .compose-attachment-retry:hover {
@@ -6867,6 +6951,19 @@
     opacity: 0.9;
   }
 
+  .compose-attachment-error-msg {
+    font-size: 10px;
+    line-height: 1.3;
+    color: white;
+    text-align: center;
+    word-break: break-all;
+    padding: 0 4px;
+    user-select: text;
+    text-shadow:
+      0 1px 3px rgba(0, 0, 0, 0.9),
+      0 0 6px rgba(0, 0, 0, 0.7);
+  }
+
   .compose-attachment-remove {
     position: absolute;
     top: 6px;

package/src/types/bindings.ts

@@ -87,6 +87,4 @@ export interface Bindings {
   CORS_ORIGINS?: EnvBindingValue;
   HOST?: string;
   PORT?: string;
-  // GitHub Sync queue (Cloudflare Queues)
-  GITHUB_SYNC_QUEUE?: Queue;
 }

package/src/types/config.ts

@@ -63,7 +63,7 @@ export const CONFIG_FIELDS = {
     envKeys: ["DEFAULT_THEME"],
   },
   DEFAULT_FONT_THEME: {
-    defaultValue: "tufte",
+    defaultValue: "classic",
     envOnly: true,
     envKeys: ["DEFAULT_FONT_THEME"],
   },

package/src/types/props.ts

@@ -22,6 +22,8 @@ export interface HomePageProps {
   currentPage: number;
   totalPages: number;
   baseUrl: string;
+  isAuthenticated: boolean;
+  signinUrl: string;
 }
 
 /** Props for the single post page component */

package/src/ui/__tests__/font-themes.test.ts

@@ -11,8 +11,8 @@ describe("BUILTIN_FONT_THEMES", () => {
     expect(BUILTIN_FONT_THEMES).toHaveLength(7);
   });
 
-  it("has 'tufte' as the first theme", () => {
-    expect(BUILTIN_FONT_THEMES[0].id).toBe("tufte");
+  it("has 'classic' as the first theme", () => {
+    expect(BUILTIN_FONT_THEMES[0].id).toBe("classic");
   });
 
   it("each theme has required fields", () => {