npm - @jant/core - Versions diffs - 0.7.0 → 0.7.1 - Mend

@jant/core 0.7.0 → 0.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (158) hide show

package/bin/commands/export.js +3 -1
package/bin/commands/import-site.js +689 -216
package/bin/commands/setup.js +136 -0
package/bin/commands/site/export.js +71 -34
package/bin/commands/site/pull-media.js +2 -6
package/bin/commands/site/snapshot/export.js +18 -60
package/bin/commands/site/snapshot/import.js +22 -23
package/bin/lib/d1-query.js +87 -2
package/bin/lib/hugo-markdown.js +4 -0
package/bin/lib/site-pull-media.js +21 -28
package/bin/lib/site-selection.js +10 -1
package/bin/lib/site-snapshot.js +338 -3
package/bin/lib/sql-export.js +68 -5
package/bin/lib/wrangler-cli.js +9 -0
package/bin/lib/zip-archive.js +187 -0
package/dist/{app-K_Aa1MMn.js → app-ZcaI1kPN.js} +732 -217
package/dist/client/.vite/manifest.json +20 -20
package/dist/client/_assets/chunks/{create-editor-CD3FhrOB.js → create-editor-B-m7X7S5.js} +50 -46
package/dist/client/_assets/chunks/{sortable-list-CgaL2jCs.js → sortable-list-BJyd-LXE.js} +1 -1
package/dist/client/_assets/chunks/{unsafe-svg-0QCkP0vZ.js → unsafe-svg-BkscJx69.js} +2 -2
package/dist/client/_assets/{client-GiYENVw8.css → client-DAhoqPdr.css} +1 -1
package/dist/client/_assets/{client-auth-k8gJ6QJj.js → client-auth-CAMfTrKW.js} +1 -1
package/dist/client/_assets/{client-compose-B_kDtWkW.js → client-compose-D6rExKVK.js} +1 -1
package/dist/client/_assets/{client-VnFxJN7G.js → client-knSEyUJO.js} +1 -1
package/dist/client/_assets/{client-manage-M90aSTOk.js → client-manage-sVOkqVbH.js} +1 -1
package/dist/client/_assets/{client-settings-DfYs9n1F.js → client-settings-CGR_nZ78.js} +7 -7
package/dist/{github-sync-BPAvT999.js → github-sync-Gw4orAHk.js} +799 -110
package/dist/index.js +2 -2
package/dist/node.js +9 -5
package/package.json +13 -3
package/src/__tests__/dev-scripts.test.ts +203 -0
package/src/__tests__/export-collection-order.test.ts +276 -0
package/src/__tests__/export-feed-ids.test.ts +184 -0
package/src/__tests__/export-feed-order.test.ts +294 -0
package/src/__tests__/export-hugo-build.test.ts +130 -0
package/src/__tests__/export-import-roundtrip.test.ts +94 -0
package/src/__tests__/export-service.test.ts +611 -28
package/src/__tests__/export-smart-collection.test.ts +329 -0
package/src/__tests__/helpers/hugo-site.ts +146 -0
package/src/__tests__/import-site-command.test.ts +487 -1
package/src/__tests__/mise-config.test.ts +75 -4
package/src/__tests__/node-dev-tasks.test.ts +264 -0
package/src/__tests__/site-export-canonical-import.test.ts +149 -0
package/src/__tests__/snapshot-canonical-replay.test.ts +179 -0
package/src/__tests__/snapshot-settings.test.ts +97 -0
package/src/__tests__/snapshot-tables.test.ts +219 -0
package/src/__tests__/sql-export.test.ts +173 -0
package/src/__tests__/zip-archive.test.ts +106 -0
package/src/app.tsx +15 -6
package/src/client/components/__tests__/jant-settings-avatar.test.ts +1 -1
package/src/client/components/__tests__/jant-settings-general.test.ts +21 -1
package/src/client/components/jant-repo-picker-types.ts +6 -1
package/src/client/components/jant-repo-picker.ts +4 -7
package/src/client/components/jant-settings-general.ts +17 -12
package/src/client/tiptap/__tests__/list-editing.test.ts +224 -86
package/src/client/tiptap/__tests__/mark-exit.test.ts +1 -2
package/src/client/tiptap/__tests__/markdown-clipboard.test.ts +26 -0
package/src/client/tiptap/extensions.ts +0 -3
package/src/client/tiptap/structural-keymap.ts +158 -47
package/src/db/__tests__/d1-query.test.ts +56 -1
package/src/i18n/locales/settings/en.po +8 -8
package/src/i18n/locales/settings/en.ts +1 -1
package/src/i18n/locales/settings/zh-Hans.po +8 -8
package/src/i18n/locales/settings/zh-Hans.ts +1 -1
package/src/i18n/locales/settings/zh-Hant.po +8 -8
package/src/i18n/locales/settings/zh-Hant.ts +1 -1
package/src/lib/__tests__/github-sync-repo-name.test.ts +40 -0
package/src/lib/__tests__/image.test.ts +27 -1
package/src/lib/__tests__/markdown-to-tiptap.test.ts +105 -0
package/src/lib/__tests__/markdown.test.ts +10 -0
package/src/lib/__tests__/resolve-config.test.ts +67 -0
package/src/lib/__tests__/schemas.test.ts +27 -1
package/src/lib/__tests__/timeline.test.ts +87 -0
package/src/lib/__tests__/tiptap-to-markdown.test.ts +172 -4
package/src/lib/discover.ts +3 -1
package/src/lib/github-sync-repo-name.ts +45 -0
package/src/lib/hugo-markdown.ts +46 -0
package/src/lib/image.ts +17 -4
package/src/lib/markdown-manager.ts +392 -2
package/src/lib/post-body-html.ts +11 -4
package/src/lib/resolve-config.ts +58 -1
package/src/lib/schemas.ts +50 -5
package/src/lib/thread-fold.ts +3 -3
package/src/lib/timeline.ts +1 -1
package/src/lib/tiptap-to-markdown.ts +13 -7
package/src/lib/url.ts +20 -0
package/src/lib/view.ts +2 -2
package/src/node/__tests__/cli-setup.test.ts +163 -0
package/src/node/__tests__/cli-site-snapshot.test.ts +67 -0
package/src/node/__tests__/cli-snapshot-meta.test.ts +20 -0
package/src/node/__tests__/runtime.test.ts +38 -0
package/src/node/index.ts +2 -0
package/src/node/request-handler.ts +3 -1
package/src/routes/api/__tests__/posts.test.ts +24 -0
package/src/routes/api/__tests__/upload.test.ts +34 -0
package/src/routes/api/export.ts +3 -3
package/src/routes/api/internal/sites.ts +0 -1
package/src/routes/api/posts.ts +2 -0
package/src/routes/api/public/posts.ts +21 -1
package/src/routes/api/upload.ts +10 -3
package/src/routes/compose.tsx +4 -0
package/src/routes/dash/__tests__/github-sync-app.test.ts +365 -0
package/src/routes/dash/settings.tsx +212 -70
package/src/routes/pages/__tests__/post-page-round-trips.test.ts +211 -0
package/src/routes/pages/__tests__/thread-order.test.ts +179 -0
package/src/routes/pages/archive.tsx +17 -11
package/src/routes/pages/featured.tsx +11 -5
package/src/routes/pages/page.tsx +53 -31
package/src/routes/pages/search.tsx +4 -2
package/src/runtime/__tests__/readiness.test.ts +23 -0
package/src/runtime/node.ts +49 -0
package/src/runtime/readiness.ts +15 -0
package/src/services/__tests__/bootstrap-setup-instance.test.ts +230 -0
package/src/services/__tests__/custom-url.test.ts +34 -0
package/src/services/__tests__/github-app-installations.test.ts +153 -0
package/src/services/__tests__/github-sync-push.test.ts +46 -0
package/src/services/__tests__/media.test.ts +31 -0
package/src/services/__tests__/path.test.ts +56 -0
package/src/services/__tests__/post-timeline.test.ts +127 -0
package/src/services/__tests__/post.test.ts +74 -0
package/src/services/bootstrap.ts +263 -44
package/src/services/custom-url.ts +2 -2
package/src/services/export-theme/layouts/_default/alias.html +27 -1
package/src/services/export-theme/layouts/_default/list.html +2 -63
package/src/services/export-theme/layouts/_default/rss.xml +27 -38
package/src/services/export-theme/layouts/collections/list.html +3 -3
package/src/services/export-theme/layouts/featured/list.html +1 -4
package/src/services/export-theme/layouts/index.html +40 -26
package/src/services/export-theme/layouts/partials/collection-members.html +100 -0
package/src/services/export-theme/layouts/partials/collection-threads.html +33 -0
package/src/services/export-theme/layouts/partials/featured-members.html +35 -0
package/src/services/export-theme/layouts/partials/featured-thread.html +1 -1
package/src/services/export-theme/layouts/partials/footer.html +1 -1
package/src/services/export-theme/layouts/partials/head.html +1 -1
package/src/services/export-theme/layouts/partials/header.html +5 -3
package/src/services/export-theme/layouts/partials/jant-data.html +23 -0
package/src/services/export-theme/layouts/partials/latest-members.html +48 -0
package/src/services/export-theme/layouts/partials/smart-collection-members.html +129 -0
package/src/services/export-theme/layouts/partials/thread-preview.html +1 -1
package/src/services/export-theme/layouts/post/list.html +1 -1
package/src/services/export-theme/layouts/smart_collection/list.html +24 -0
package/src/services/export-theme/styles/main.css +0 -1
package/src/services/export-theme/theme.toml +1 -1
package/src/services/export.ts +620 -71
package/src/services/github-app-installations.ts +171 -4
package/src/services/github-sync.ts +69 -15
package/src/services/mcp.ts +19 -1
package/src/services/media.ts +8 -1
package/src/services/path.ts +34 -1
package/src/services/post.ts +214 -39
package/src/services/site-admin.ts +3 -7
package/src/services/site.ts +83 -31
package/src/styles/ui.css +7 -1
package/src/types/app-context.ts +16 -0
package/src/types/bindings.ts +5 -0
package/src/types/operations.ts +10 -0
package/src/ui/dash/settings/GeneralContent.tsx +10 -8
package/src/client/tiptap/exitable-marks.ts +0 -73

package/src/routes/pages/__tests__/thread-order.test.ts ADDED Viewed

@@ -0,0 +1,179 @@
+/**
+ * Thread order on the public surfaces when a reply is older than its root.
+ *
+ * A post moved into a Thread keeps its own creation time, and an export
+ * without `created` dates every post by its publication, so a Thread's replies
+ * can carry a `createdAt` earlier than the root's. Thread order still opens on
+ * the root: every page and feed that reads the first post as the root has to
+ * find it there, or the Thread drops out of Featured and Collections and its
+ * page canonicalizes to a reply.
+ */
+import { eq } from "drizzle-orm";
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { posts as postTable } from "../../../db/schema.js";
+import { toISOString } from "../../../lib/time.js";
+import { collectionRoutes } from "../collection.js";
+import { collectionsPageRoutes } from "../collections.js";
+import { featuredRoutes } from "../featured.js";
+import { pageRoutes } from "../page.js";
+const ROOT_TEXT = "Root body text";
+const FIRST_TEXT = "First reply text";
+const SECOND_TEXT = "Second reply text";
+function createThreadOrderTestApp(options: { authenticated?: boolean } = {}) {
+  const testApp = createTestApp(options);
+  const { app } = testApp;
+  app.use("*", async (c, next) => {
+    c.set("publicPath", c.req.path);
+    c.set("publicRequestUrl", c.req.url);
+    await next();
+  });
+  app.route("/featured", featuredRoutes);
+  app.route("/collections", collectionsPageRoutes);
+  app.route("/collections", collectionRoutes);
+  app.route("/", pageRoutes);
+  return testApp;
+}
+/**
+ * A featured root published after its two replies, with creation times to
+ * match — the shape a site rebuilt from a pre-`created` export holds.
+ */
+async function createThreadWithOlderReplies(
+  testApp: ReturnType<typeof createThreadOrderTestApp>,
+) {
+  const { services, db } = testApp;
+  const root = await services.posts.create({
+    format: "note",
+    title: "Thread root",
+    bodyMarkdown: ROOT_TEXT,
+    featured: true,
+    publishedAt: 3000,
+  });
+  const first = await services.posts.create({
+    format: "note",
+    bodyMarkdown: FIRST_TEXT,
+    replyToId: root.id,
+    publishedAt: 1000,
+  });
+  const second = await services.posts.create({
+    format: "note",
+    bodyMarkdown: SECOND_TEXT,
+    replyToId: first.id,
+    publishedAt: 2000,
+  });
+  for (const [id, createdAt] of [
+    [root.id, 3000],
+    [first.id, 1000],
+    [second.id, 2000],
+  ] as const) {
+    await db.update(postTable).set({ createdAt }).where(eq(postTable.id, id));
+  }
+  return { root, first, second };
+}
+/**
+ * Assert the three posts appear root first, in Thread order. A page's `<head>`
+ * repeats the visited post's text, so only the body counts.
+ */
+function expectRootFirst(markup: string) {
+  const bodyStart = markup.indexOf("<body");
+  const body = bodyStart === -1 ? markup : markup.slice(bodyStart);
+  const root = body.indexOf(ROOT_TEXT);
+  const first = body.indexOf(FIRST_TEXT);
+  const second = body.indexOf(SECOND_TEXT);
+  expect(root).toBeGreaterThan(-1);
+  expect(first).toBeGreaterThan(root);
+  expect(second).toBeGreaterThan(first);
+}
+/** The post whose `<article>` holds the markup at `index`. */
+function postIdAt(html: string, index: number): string | undefined {
+  const articles = html
+    .slice(0, index)
+    .matchAll(/<article\b[^>]*\bdata-post-id="([^"]+)"/g);
+  return [...articles].at(-1)?.[1];
+}
+function extractCanonicalHref(html: string): string | null {
+  const match = html.match(/<link\s+rel="canonical"\s+href="([^"]+)"\s*\/?>/i);
+  return match?.[1] ?? null;
+}
+describe("Thread order with replies older than the root", () => {
+  it("opens the Thread page on the root and points its canonical there", async () => {
+    const testApp = createThreadOrderTestApp();
+    const { root, second } = await createThreadWithOlderReplies(testApp);
+    const res = await testApp.app.request(`/${second.slug}`);
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expectRootFirst(html);
+    expect(extractCanonicalHref(html)).toMatch(new RegExp(`/${root.slug}$`));
+    // The page describes the Thread as one article, dated by its root.
+    expect(html).toContain(
+      `<meta property="article:published_time" content="${toISOString(3000)}"/>`,
+    );
+    expect(html).toContain(`"datePublished":"${toISOString(3000)}"`);
+  });
+  it("offers the author a reply on the newest reply, not the root", async () => {
+    const testApp = createThreadOrderTestApp({ authenticated: true });
+    const { root, second } = await createThreadWithOlderReplies(testApp);
+    const html = await (await testApp.app.request(`/${root.slug}`)).text();
+    expect(html.match(/data-reply-trigger/g)).toHaveLength(1);
+    expect(postIdAt(html, html.indexOf("data-reply-trigger"))).toBe(second.id);
+  });
+  it("keeps the Thread on the Featured page", async () => {
+    const testApp = createThreadOrderTestApp();
+    await createThreadWithOlderReplies(testApp);
+    const res = await testApp.app.request("/featured");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    // The curated view shows the root and the Thread's final post, with the
+    // reply between them folded into a gap.
+    expect(html).toContain(ROOT_TEXT);
+    expect(html).not.toContain(FIRST_TEXT);
+    expect(html.indexOf(SECOND_TEXT)).toBeGreaterThan(html.indexOf(ROOT_TEXT));
+  });
+  it("keeps the Thread in the Featured feed", async () => {
+    const testApp = createThreadOrderTestApp();
+    const { root } = await createThreadWithOlderReplies(testApp);
+    const res = await testApp.app.request("/featured/feed");
+    expect(res.status).toBe(200);
+    const xml = await res.text();
+    expect(xml.match(/<entry>/g)).toHaveLength(1);
+    expect(xml).toContain(`/${root.slug}`);
+    expectRootFirst(xml);
+  });
+  it("opens the Thread on its root on a Collection page", async () => {
+    const testApp = createThreadOrderTestApp();
+    const collection = await testApp.services.collections.create({
+      slug: "reading",
+      title: "Reading",
+    });
+    const { root } = await createThreadWithOlderReplies(testApp);
+    await testApp.services.collections.addThread(collection.id, root.id);
+    const res = await testApp.app.request(`/${collection.slug}`);
+    expect(res.status).toBe(200);
+    expectRootFirst(await res.text());
+  });
+});

package/src/routes/pages/archive.tsx CHANGED Viewed

@@ -432,10 +432,14 @@ export async function renderArchivePage(
   if (params.collectionMissing) return c.notFound();
-  const navData = await getNavigationData(c);
+  // The chrome is independent of every query below, so it goes out with them
+  // rather than ahead of them. Its `isAuthenticated` is `c.var.isAuthenticated`
+  // verbatim, which is what the filters below read.
+  const navDataPromise = getNavigationData(c);
+  const isAuthenticated = c.var.isAuthenticated;
   const filters = buildArchivePostFilters(params, {
-    isAuthenticated: navData.isAuthenticated,
+    isAuthenticated,
     lang: getViewLang(c) ?? undefined,
   });
@@ -456,13 +460,14 @@ export async function renderArchivePage(
   // media EXISTS subqueries.
   const baselineFilters = hasActiveArchiveFilter(params.selection)
     ? buildArchivePostFilters(params, {
-        isAuthenticated: navData.isAuthenticated,
+        isAuthenticated,
         lang: filters.lang,
         selection: {},
       })
     : undefined;
   const [
+    navData,
     totalCount,
     baselineCount,
     monthlyCounts,
@@ -470,6 +475,7 @@ export async function renderArchivePage(
     availableYears,
     listedCollections,
   ] = await Promise.all([
+    navDataPromise,
     services.posts.count(filters),
     baselineFilters
       ? services.posts.count(baselineFilters)
@@ -502,13 +508,6 @@ export async function renderArchivePage(
   const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
   const mediaCtx = createMediaContext(appConfig);
-  const allPostIds = posts.map((p) => p.id);
-  const archiveAliasesMap =
-    await c.var.services.paths.getPostAliases(allPostIds);
-  const archiveAliasMap = new Map<string, string>();
-  for (const [id, aliases] of archiveAliasesMap) {
-    if (aliases[0]) archiveAliasMap.set(id, aliases[0]);
-  }
   // --- List view: flat timeline items (no month grouping) ------------------
@@ -543,10 +542,17 @@ export async function renderArchivePage(
     );
     const postIds = posts.map((p) => p.id);
-    const [rawMediaMap, replyCounts] = await Promise.all([
+    // Only the grid renders permalinks from this map. The list view goes
+    // through `assembleTimelineItems`, which loads the same aliases itself.
+    const [rawMediaMap, replyCounts, archiveAliasesMap] = await Promise.all([
       services.media.getByPostIds(postIds),
       services.posts.getReplyCounts(postIds),
+      services.paths.getPostAliases(postIds),
     ]);
+    const archiveAliasMap = new Map<string, string>();
+    for (const [id, aliases] of archiveAliasesMap) {
+      if (aliases[0]) archiveAliasMap.set(id, aliases[0]);
+    }
     const mediaMap = buildMediaMap(
       rawMediaMap,
       mediaCtx.r2PublicUrl,

package/src/routes/pages/featured.tsx CHANGED Viewed

@@ -32,7 +32,10 @@ export const featuredRoutes = new Hono<Env>();
  * @returns Featured page response
  */
 export async function renderFeaturedPage(c: Context<Env>): Promise<Response> {
-  const navData = await getNavigationData(c);
+  // The chrome and the timeline are independent, so they load together. The
+  // timeline only ever wanted `navData.isAuthenticated`, which is
+  // `c.var.isAuthenticated` verbatim.
+  const navDataPromise = getNavigationData(c);
   const i18n = getI18n(c);
   const page = parsePageNumber(c.req.query("page"));
@@ -43,10 +46,13 @@ export async function renderFeaturedPage(c: Context<Env>): Promise<Response> {
     }),
   );
   const paginatedPageTitle = formatPageLabel(page);
-  const { items, currentPage, totalPages } = await assembleFeaturedTimeline(c, {
-    page,
-    isAuthenticated: navData.isAuthenticated,
-  });
+  const [navData, { items, currentPage, totalPages }] = await Promise.all([
+    navDataPromise,
+    assembleFeaturedTimeline(c, {
+      page,
+      isAuthenticated: c.var.isAuthenticated,
+    }),
+  ]);
   return renderPublicPage(c, {
     title:

package/src/routes/pages/page.tsx CHANGED Viewed

@@ -24,6 +24,7 @@ import {
 } from "../../lib/post-display.js";
 import { buildArticleJsonLd } from "../../lib/structured-data.js";
 import {
+  normalizePath,
   toAbsoluteAssetUrl,
   toAbsoluteSiteUrl,
   toPublicHref,
@@ -39,6 +40,7 @@ import {
 import { getOrBuildEntry } from "../../i18n/supported-locales.js";
 import { ABOUT_PAGE_SLUG } from "../../services/about-page.js";
 import { isTextAttachment } from "../../services/media.js";
+import type { ResolvedPath } from "../../services/path.js";
 import type { Post } from "../../types.js";
 import { renderArchivePage } from "./archive.js";
 import { renderCollectionFeed, renderCollectionPage } from "./collection.js";
@@ -68,10 +70,10 @@ interface TextPreviewAutoOpen {
  * content at every reply URL. Point the canonical to the thread root so
  * crawlers consolidate ranking on one URL.
  *
- * The root post is always at index 0 of `threadPostViews` (getThread orders
- * by createdAt ASC, and the DB check constraint guarantees root has the
- * smallest createdAt in its thread). When `threadPostViews` is undefined the
- * post is not part of a multi-post thread, so the post itself is the root.
+ * The root post is always at index 0 of `threadPostViews`: Thread order puts
+ * the root first even when a reply is older than it. When `threadPostViews` is
+ * undefined the post is not part of a multi-post thread, so the post itself is
+ * the root.
  */
 function buildPostCanonicalHref(
   postView: { permalink: string },
@@ -432,6 +434,29 @@ pageRoutes.get("/preview/:slug", requireAuth(), async (c) => {
   return renderPost(c, post, { allowDraft: true, isPreview: true });
 });
+/**
+ * Resolve a stored path, reusing the lookup the stored-redirect middleware
+ * already made for this request's own address.
+ *
+ * Only that one address is reusable: a `/feed` suffix or a text deep link asks
+ * about a different path, and a language view strips its prefix before asking,
+ * so the stored form is compared rather than assumed.
+ *
+ * @param c - Hono context
+ * @param storedPath - Registry path form, without a leading slash
+ * @returns The resolved record, or null when nothing is registered there
+ */
+async function resolveStoredPath(
+  c: Context<Env>,
+  storedPath: string,
+): Promise<ResolvedPath | null> {
+  const lookup = c.var.pathLookup;
+  if (lookup && lookup.path === normalizePath(storedPath)) {
+    return lookup.record;
+  }
+  return c.var.services.paths.resolve(storedPath);
+}
 /**
  * Resolve a path through the path registry: posts, collections, their aliases,
  * archive URLs, stored redirects, and text-attachment deep links.
@@ -459,7 +484,7 @@ export async function renderRegisteredPath(c: Context<Env>): Promise<Response> {
   // Stored redirects outrank the normal post/collection/deep-link resolvers,
   // but can never shadow an explicit or reserved application route.
-  const resolved = await c.var.services.paths.resolve(fullPath);
+  const resolved = await resolveStoredPath(c, fullPath);
   if (resolved?.kind === "redirect" && resolved.redirectToPath) {
     const target = `/${resolved.redirectToPath}`;
     // Follow the stored redirect within the current view; the hop that lands
@@ -528,26 +553,25 @@ export async function renderRegisteredPath(c: Context<Env>): Promise<Response> {
     const resolvedPost = await c.var.services.paths.resolve(slugPart);
     if (resolvedPost?.postId) {
-      const post = await c.var.services.posts.getById(resolvedPost.postId);
+      const loaded = await c.var.services.posts.getWithCanonicalAlias(
+        resolvedPost.postId,
+      );
+      const post = loaded?.post;
       if (!post || post.status === "draft") return c.notFound();
-      if (post.visibility === "private") {
-        const navData = await getNavigationData(c);
-        if (!navData.isAuthenticated) return c.notFound();
+      if (post.visibility === "private" && !c.var.isAuthenticated) {
+        return c.notFound();
       }
       // Redirect slug → alias if one exists (same pattern as post pages)
-      if (resolvedPost.kind === "slug") {
-        const alias = await c.var.services.customUrls.getByTarget(
-          "post",
-          post.id,
+      if (resolvedPost.kind === "slug" && loaded.canonicalAlias) {
+        return c.redirect(
+          toPublicPath(
+            `${loaded.canonicalAlias}/text/${mediaId}`,
+            sitePathPrefix,
+          ),
+          301,
         );
-        if (alias) {
-          return c.redirect(
-            toPublicPath(`/${alias.path}/text/${mediaId}`, sitePathPrefix),
-            301,
-          );
-        }
       }
       // A text attachment belongs to a post, so it inherits that post's single
@@ -597,26 +621,24 @@ export async function renderRegisteredPath(c: Context<Env>): Promise<Response> {
   }
   if (resolved.postId) {
-    const post = await c.var.services.posts.getById(resolved.postId);
+    const loaded = await c.var.services.posts.getWithCanonicalAlias(
+      resolved.postId,
+    );
+    const post = loaded?.post;
     if (!post) return c.notFound();
     const allowDraft = canRenderDraftAboutEditor(c, fullPath, post);
     if (post.status === "draft" && !allowDraft) return c.notFound();
-    if (post.visibility === "private") {
-      const navData = await getNavigationData(c);
-      if (!navData.isAuthenticated) return c.notFound();
+    if (post.visibility === "private" && !c.var.isAuthenticated) {
+      return c.notFound();
     }
     // If accessed via slug but an alias exists, the alias is canonical.
-    let canonicalPath = `/${fullPath}`;
-    if (resolved.kind === "slug") {
-      const alias = await c.var.services.customUrls.getByTarget(
-        "post",
-        post.id,
-      );
-      if (alias) canonicalPath = `/${alias.path}`;
-    }
+    const canonicalPath =
+      resolved.kind === "slug" && loaded.canonicalAlias
+        ? loaded.canonicalAlias
+        : `/${fullPath}`;
     // One address per post: a language-prefixed URL is only ever a way in.
     if (inLanguageView || canonicalPath !== `/${fullPath}`) {

package/src/routes/pages/search.tsx CHANGED Viewed

@@ -31,7 +31,8 @@ export async function renderSearchPage(c: Context<Env>): Promise<Response> {
   const pageParam = c.req.query("page");
   const page = pageParam ? Math.max(1, parseInt(pageParam, 10) || 1) : 1;
-  const navData = await getNavigationData(c);
+  // The chrome does not gate the query, so it loads alongside it.
+  const navDataPromise = getNavigationData(c);
   // Only search if there's a query
   let results: SearchResult[] = [];
@@ -63,7 +64,8 @@ export async function renderSearchPage(c: Context<Env>): Promise<Response> {
   // Transform to View Models
   const mediaCtx = createMediaContext(c.var.appConfig);
   const postIds = results.map((r) => r.post.id);
-  const [aliasesMap, collectionsMap] = await Promise.all([
+  const [navData, aliasesMap, collectionsMap] = await Promise.all([
+    navDataPromise,
     c.var.services.paths.getPostAliases(postIds),
     c.var.services.collections.getCollectionsByPostIds(postIds),
   ]);

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

@@ -24,6 +24,7 @@ describe("getInstanceReadiness", () => {
       }),
     ).resolves.toEqual({
       status: "ok",
+      version: "test-version",
       checks: {
         startupConfig: { ok: true },
         database: { ok: true },
@@ -40,6 +41,7 @@ describe("getInstanceReadiness", () => {
       }),
     ).resolves.toEqual({
       status: "error",
+      version: "test-version",
       checks: {
         startupConfig: {
           ok: false,
@@ -104,6 +106,26 @@ describe("getInstanceReadiness", () => {
     );
   });
+  // What a deploy check compares: the build that answers, and when its
+  // process started. A Worker has no process, so it reports only the build.
+  it("reports the build, and the process start where there is one", async () => {
+    const { sqlite } = createTestDatabase();
+    const env = {
+      AUTH_SECRET: "test-secret-with-enough-entropy-for-readiness",
+      NODE_SQLITE: sqlite,
+    };
+    const withoutStart = await getInstanceReadiness(env);
+    expect(withoutStart.version).toBe("test-version");
+    expect(withoutStart).not.toHaveProperty("startedAt");
+    const withStart = await getInstanceReadiness({
+      ...env,
+      NODE_STARTED_AT: 1789000000,
+    });
+    expect(withStart.startedAt).toBe(1789000000);
+  });
   it("reports a missing database binding", async () => {
     await expect(
       getInstanceReadiness({
@@ -111,6 +133,7 @@ describe("getInstanceReadiness", () => {
       }),
     ).resolves.toEqual({
       status: "error",
+      version: "test-version",
       checks: {
         startupConfig: { ok: true },
         database: {

package/src/runtime/node.ts CHANGED Viewed

@@ -12,14 +12,21 @@ import {
   shouldUseSecureCookies,
 } from "../lib/env.js";
 import { createHostedControlPlaneClient } from "../lib/hosted-control-plane.js";
+import { ValidationError } from "../lib/errors.js";
 import { createMemoryRateLimiter } from "../lib/rate-limit-memory.js";
 import type { RateLimiter } from "../lib/rate-limit.js";
+import { InstanceSetupSchema } from "../lib/schemas.js";
 import { createStorageDriver, type StorageDriver } from "../lib/storage.js";
 import {
   createHostedHandoffService,
   type HostedHandoffService,
 } from "../services/hosted-handoff.js";
+import {
+  createBootstrapService,
+  type SetUpInstanceResult,
+} from "../services/bootstrap.js";
 import { createServices, type Services } from "../services/index.js";
+import { TRANSIENT_SINGLE_SITE_ID } from "../services/site.js";
 import type { Site, SiteDomain } from "../types/entities.js";
 import type { Bindings } from "../types/bindings.js";
 import {
@@ -229,3 +236,45 @@ export async function createNodeCliRuntime(
     storage: createStorageDriver(env),
   };
 }
+/**
+ * Set up a self-hosted Node install without a browser, the way the two setup
+ * screens would. Backs `jant setup`.
+ *
+ * @param env - Bindings with a resolved `NODE_DATABASE`
+ * @param input - The owner's credentials and the site's answers, unvalidated
+ * @returns What setup found, and the site
+ * @throws {ValidationError} When the input fails `InstanceSetupSchema`
+ * @throws {Error} Whenever `BootstrapService.setUpInstance` refuses
+ * @example
+ * ```ts
+ * await setUpNodeInstance(bindings, {
+ *   email: "owner@example.com",
+ *   password: "correct horse battery",
+ * });
+ * ```
+ */
+export async function setUpNodeInstance(
+  env: Bindings,
+  input: unknown,
+): Promise<SetUpInstanceResult> {
+  const nodeDatabase = env.NODE_DATABASE;
+  if (!nodeDatabase) {
+    throw new Error("Node setup requires a resolved database binding.");
+  }
+  const parsed = InstanceSetupSchema.safeParse(input);
+  if (!parsed.success) {
+    throw new ValidationError(
+      parsed.error.issues[0]?.message ?? "Invalid setup input.",
+    );
+  }
+  // No request resolved a site, and setup never reads the one it is bound to.
+  return createBootstrapService(nodeDatabase.db, TRANSIENT_SINGLE_SITE_ID, {
+    schema: nodeDatabase.schema,
+    databaseDialect: nodeDatabase.dialect,
+    bootstrapSite: getSingleSiteBootstrapOptions(env),
+    siteResolutionMode: getSiteResolutionMode(env),
+  }).setUpInstance(parsed.data);
+}

package/src/runtime/readiness.ts CHANGED Viewed

@@ -5,6 +5,7 @@ import {
   getAuthSecretReadinessError,
   getHostBasedStartupConfigurationIssues,
 } from "../lib/startup-config.js";
+import { CORE_VERSION } from "../lib/version.js";
 import { createSiteService } from "../services/site.js";
 import type { Bindings } from "../types/bindings.js";
@@ -15,6 +16,15 @@ export interface ReadinessCheckStatus {
 export interface InstanceReadinessResult {
   status: "ok" | "error";
+  /** The running build: the package version, then the build's commit id. */
+  version: string;
+  /**
+   * When the Node process started serving, in Unix seconds. With `version`,
+   * it lets a deploy check from outside that the instance answering is one
+   * started after the deploy, not an older one a rollback left running.
+   * Absent on Workers.
+   */
+  startedAt?: number;
   checks: {
     startupConfig: ReadinessCheckStatus;
     database: ReadinessCheckStatus;
@@ -117,6 +127,7 @@ export async function getInstanceReadiness(
     | "INTERNAL_ADMIN_TOKEN"
     | "NODE_DATABASE"
     | "NODE_SQLITE"
+    | "NODE_STARTED_AT"
     | "SITE_RESOLUTION_MODE"
   >,
 ): Promise<InstanceReadinessResult> {
@@ -125,6 +136,10 @@ export async function getInstanceReadiness(
   return {
     status: startupConfig.ok && database.ok ? "ok" : "error",
+    version: CORE_VERSION,
+    ...(env.NODE_STARTED_AT === undefined
+      ? {}
+      : { startedAt: env.NODE_STARTED_AT }),
     checks: {
       startupConfig,
       database,