@jant/core 0.7.0 → 0.7.1

package/src/services/post.ts

@@ -275,7 +275,7 @@ export interface CollectionFeedEntry {
 
 export interface FeaturedThreadTimelinePost {
   post: Post;
-  /** Zero-based position among the Thread's published Posts. */
+  /** Zero-based position among the Thread's published Posts; the root is 0. */
   position: number;
 }
 
@@ -344,8 +344,37 @@ export type TranslationCandidateResolution =
   /** Its group already holds this Thread's language. */
   | { status: "group_language_taken"; language: string };
 
+/** A Post together with the custom URL that has taken over as its address. */
+export interface PostWithCanonicalAlias {
+  post: Post;
+  /**
+   * The newest registered `alias`, which is the address a slug URL redirects
+   * to. Null when the Post still answers at its slug.
+   */
+  canonicalAlias: string | null;
+}
+
 export interface PostService {
   getById(id: string): Promise<Post | null>;
+  /**
+   * The Post a resolved path points at, plus its canonical address, in one
+   * read.
+   *
+   * Serving a Post URL needs three things the registry and the Post row hold
+   * between them: the row, the Post's slug, and whether a custom URL has taken
+   * over as its address. Asking for those separately put three round trips at
+   * the head of every Post page, so they come back together.
+   *
+   * @param postId - TypeID of the Post
+   * @returns The hydrated Post and its canonical alias, or null when no such
+   *   Post exists or it has no slug
+   * @example
+   * ```ts
+   * const loaded = await posts.getWithCanonicalAlias(resolved.postId);
+   * if (loaded?.canonicalAlias) redirect(loaded.canonicalAlias);
+   * ```
+   */
+  getWithCanonicalAlias(postId: string): Promise<PostWithCanonicalAlias | null>;
   getBodyContent(id: string): Promise<PostBodyContent | null>;
   getBySlug(slug: string): Promise<Post | null>;
   suggestSlug(input: {
@@ -476,6 +505,10 @@ export interface PostService {
    * Used when replacing a saved thread draft with a new version.
    */
   deleteThreadDraft(id: string, deps?: PostDeleteDeps): Promise<boolean>;
+  /**
+   * Every Post in a Thread, drafts included, in Thread order: the root first,
+   * then replies by creation time, then ID.
+   */
   getThread(rootId: string): Promise<Post[]>;
   /**
    * 1-based position of a Post in the reply chain running from its Thread root
@@ -663,7 +696,10 @@ export interface PostService {
     collectionIds: string[],
     options?: CollectionFeedEntryOptions,
   ): Promise<CollectionFeedEntry[]>;
-  /** Fetch published Posts for each requested Thread root. */
+  /**
+   * Fetch published Posts for each requested Thread root, in Thread order: the
+   * root first, then replies by creation time, then ID.
+   */
   getPublishedThreads(
     rootIds: string[],
     options?: Pick<PostFilters, "publishedBefore">,
@@ -671,7 +707,8 @@ export interface PostService {
   /** Get distinct years with posts, bucketed on the `sortBy` time axis */
   getDistinctYears(filters?: PostFilters): Promise<number[]>;
   /**
-   * For each Thread ID, resolve the Post that currently ends the chain.
+   * For each Thread ID, resolve the Post that currently ends the chain: the
+   * last in Thread order, so the root only while it has no replies.
    *
    * Two callers need two different answers. Readers ask what the audience can
    * see, so drafts must not count — the Reply affordance belongs on the last
@@ -757,6 +794,9 @@ export async function rebuildPostBodyHtmlWithRuntimeSettings(
 
 const SLUG_RE = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
 
+const INVALID_POST_BODY_MESSAGE =
+  "The body isn't a TipTap JSON document. Send a doc node as a JSON string, or send Markdown as bodyMarkdown.";
+
 function isValidSlug(value: string): boolean {
   return SLUG_RE.test(value);
 }
@@ -952,6 +992,33 @@ export function createPostService(
     return posts.publishedAt;
   }
 
+  /**
+   * Thread order: the root first, then replies by creation time, then ID.
+   *
+   * The root leads whatever its own `createdAt` says. A reply can be older
+   * than its root — a post moved into a Thread keeps its creation time, and an
+   * export without `created` dates every post by publication — and ordering
+   * on time alone would open such a Thread on a reply. Every surface that
+   * reads the first post as the root would then lose it: the Thread page's
+   * canonical URL, Featured, Collections, the feeds, and the reply guard's
+   * idea of where the Thread ends. Every query that orders a Thread's posts
+   * goes through here so they agree.
+   *
+   * @param direction - `desc` walks from the Thread's end back to its root
+   * @returns ORDER BY terms, placed after any partitioning column
+   * @example
+   * db.select().from(posts).orderBy(posts.threadId, ...threadOrder());
+   * sql`ROW_NUMBER() OVER (ORDER BY ${sql.join(threadOrder(), sql`, `)})`;
+   */
+  function threadOrder(direction: "asc" | "desc" = "asc"): SQL[] {
+    const terms = [
+      sql`CASE WHEN ${posts.replyToId} IS NULL THEN 0 ELSE 1 END`,
+      sql`${posts.createdAt}`,
+      sql`${posts.id}`,
+    ];
+    return direction === "asc" ? terms : terms.map((term) => desc(term));
+  }
+
   function buildYearMonthExpr(column: SQLWrapper): SQL<string> {
     return databaseDialect === "pg"
       ? sql<string>`to_char(timezone('UTC', to_timestamp(${column})), 'YYYY-MM')`
@@ -1542,14 +1609,80 @@ export function createPostService(
     };
   }
 
+  /**
+   * Thread visibility the loaded rows already answer, plus the thread ids they
+   * do not.
+   *
+   * A reply's own `visibility` column is null — it inherits the root's — so a
+   * row only speaks for its thread when it *is* the root. List surfaces query
+   * thread roots exclusively (`excludeReplies`), so for them this covers every
+   * thread and the follow-up read never runs.
+   *
+   * Entries are set only for a non-null visibility, matching
+   * {@link getThreadVisibilityMap}: a root row with no visibility is treated as
+   * unreadable by both paths.
+   */
+  function seedThreadVisibility(rows: (typeof posts.$inferSelect)[]): {
+    known: Map<string, Visibility>;
+    missingThreadIds: string[];
+  } {
+    const known = new Map<string, Visibility>();
+    const covered = new Set<string>();
+    for (const row of rows) {
+      if (row.id !== row.threadId) continue;
+      covered.add(row.threadId);
+      if (row.visibility) {
+        known.set(row.threadId, ensurePostVisibility(row.visibility, Error));
+      }
+    }
+    const missingThreadIds = [
+      ...new Set(
+        rows
+          .map((row) => row.threadId)
+          .filter((threadId) => !covered.has(threadId)),
+      ),
+    ];
+    return { known, missingThreadIds };
+  }
+
+  /**
+   * Slug lookup and root-visibility lookup are independent, so they go out
+   * together rather than one after the other.
+   */
+  async function loadHydrationMaps(
+    rows: (typeof posts.$inferSelect)[],
+  ): Promise<{
+    slugMap: Map<string, string>;
+    visibilityMap: Map<string, Visibility>;
+  }> {
+    const { known, missingThreadIds } = seedThreadVisibility(rows);
+    const [slugMap, fetched] = await Promise.all([
+      resolvedPaths.getPostSlugMap(rows.map((row) => row.id)),
+      missingThreadIds.length > 0
+        ? getThreadVisibilityMap(missingThreadIds)
+        : Promise.resolve(new Map<string, Visibility>()),
+    ]);
+    for (const [threadId, visibility] of fetched) {
+      known.set(threadId, visibility);
+    }
+    return { slugMap, visibilityMap: known };
+  }
+
   async function hydratePost(
     row: typeof posts.$inferSelect | undefined,
+    knownSlug?: string,
   ): Promise<Post | null> {
     if (!row) return null;
-    const slug = await resolvedPaths.getPostSlug(row.id);
+    const { known, missingThreadIds } = seedThreadVisibility([row]);
+    const [slug, fetched] = await Promise.all([
+      knownSlug ?? resolvedPaths.getPostSlug(row.id),
+      missingThreadIds.length > 0
+        ? getThreadVisibilityMap(missingThreadIds)
+        : Promise.resolve(new Map<string, Visibility>()),
+    ]);
     if (!slug) return null;
-    const rootVisibilityMap = await getThreadVisibilityMap([row.threadId]);
-    const visibility = rootVisibilityMap.get(row.threadId) ?? row.visibility;
+    const visibility =
+      known.get(row.threadId) ?? fetched.get(row.threadId) ?? row.visibility;
     if (!visibility) return null;
     return toPost(row, slug, visibility);
   }
@@ -1558,17 +1691,11 @@ export function createPostService(
     rows: (typeof posts.$inferSelect)[],
   ): Promise<Post[]> {
     if (rows.length === 0) return [];
-    const slugMap = await resolvedPaths.getPostSlugMap(
-      rows.map((row) => row.id),
-    );
-    const rootVisibilityMap = await getThreadVisibilityMap(
-      rows.map((row) => row.threadId),
-    );
+    const { slugMap, visibilityMap } = await loadHydrationMaps(rows);
     return rows
       .map((row) => {
         const slug = slugMap.get(row.id);
-        const visibility =
-          rootVisibilityMap.get(row.threadId) ?? row.visibility;
+        const visibility = visibilityMap.get(row.threadId) ?? row.visibility;
         return slug && visibility ? toPost(row, slug, visibility) : null;
       })
       .filter((row): row is Post => row !== null);
@@ -1883,6 +2010,45 @@ export function createPostService(
       return hydratePost(result[0]);
     },
 
+    async getWithCanonicalAlias(postId) {
+      const rows = await db
+        .select({ post: posts, path: pathRegistry })
+        .from(posts)
+        .leftJoin(
+          pathRegistry,
+          and(
+            eq(pathRegistry.siteId, siteId),
+            eq(pathRegistry.postId, posts.id),
+          ),
+        )
+        .where(and(eq(posts.siteId, siteId), eq(posts.id, postId)))
+        .orderBy(asc(pathRegistry.createdAt), asc(pathRegistry.id));
+
+      const row = rows[0];
+      if (!row) return null;
+
+      let slug: string | null = null;
+      let canonicalAlias: string | null = null;
+      for (const { path } of rows) {
+        if (!path) continue;
+        if (path.kind === "slug") {
+          slug = path.path;
+          continue;
+        }
+        // Rows arrive oldest first, so the last `alias` seen is the newest —
+        // the one a slug URL redirects to. Ties within a second fall to the
+        // higher id rather than to whatever the storage engine returned first.
+        if (path.kind === "alias") canonicalAlias = `/${path.path}`;
+      }
+
+      // A Post with no slug row has no address, which is what `hydratePost`
+      // says by returning null for it.
+      if (!slug) return null;
+
+      const post = await hydratePost(row.post, slug);
+      return post ? { post, canonicalAlias } : null;
+    },
+
     async getBodyContent(id) {
       const post = await this.getById(id);
       if (!post) return null;
@@ -1902,7 +2068,14 @@ export function createPostService(
       if (!resolved || resolved.kind !== "slug" || !resolved.postId) {
         return null;
       }
-      return this.getById(resolved.postId);
+      const result = await db
+        .select()
+        .from(posts)
+        .where(and(eq(posts.siteId, siteId), eq(posts.id, resolved.postId)))
+        .limit(1);
+      // The registry row that answered is the slug, so hydration does not go
+      // back for it.
+      return hydratePost(result[0], resolved.path);
     },
 
     async suggestSlug(input) {
@@ -2224,6 +2397,9 @@ export function createPostService(
       const preparedBody = trimmedBody
         ? tryPreparePostBodyHtml(id, trimmedBody)
         : null;
+      if (preparedBody && !preparedBody.ok) {
+        throw new ValidationError(INVALID_POST_BODY_MESSAGE);
+      }
       const body = preparedBody?.ok ? preparedBody.body : trimmedBody;
       const title = data.title?.trim() || null;
       const quoteText = data.quoteText?.trim() || null;
@@ -2404,6 +2580,8 @@ export function createPostService(
       assertDraftPublishedAt(status, data.publishedAt);
       const publishedAt =
         status === "published" ? (data.publishedAt ?? timestamp) : null;
+      const createdAt = data.createdAt ?? timestamp;
+      const updatedAt = data.updatedAt ?? createdAt;
 
       // Resolve slug from slug, path, or title
       let slug: string;
@@ -2563,10 +2741,10 @@ export function createPostService(
               translationGroupId,
               quietReply: isQuietReply,
               publishedAt,
-              lastActivityAt: publishedAt ?? timestamp,
-              threadUpdatedAt: publishedAt ?? timestamp,
-              createdAt: timestamp,
-              updatedAt: timestamp,
+              lastActivityAt: publishedAt ?? updatedAt,
+              threadUpdatedAt: publishedAt ?? updatedAt,
+              createdAt,
+              updatedAt,
             }),
           );
 
@@ -2657,10 +2835,10 @@ export function createPostService(
               translationGroupId,
               quietReply: isQuietReply,
               publishedAt,
-              lastActivityAt: publishedAt ?? timestamp,
-              threadUpdatedAt: publishedAt ?? timestamp,
-              createdAt: timestamp,
-              updatedAt: timestamp,
+              lastActivityAt: publishedAt ?? updatedAt,
+              threadUpdatedAt: publishedAt ?? updatedAt,
+              createdAt,
+              updatedAt,
             });
 
             await tx.insert(pathRegistry).values({
@@ -2787,8 +2965,8 @@ export function createPostService(
         // A reply with no date of its own belongs to the root's moment, not to
         // whenever the request happened to run. Without this, backdating the
         // root leaves its replies stamped today and the thread reads as if it
-        // spanned years. Thread order is by `createdAt`/`id` (see the thread
-        // queries), so sharing one `publishedAt` cannot reorder anything.
+        // spanned years. Thread order is the root, then `createdAt`/`id` (see
+        // `threadOrder`), so sharing one `publishedAt` cannot reorder anything.
         const rootPublishedAt = created[0]?.publishedAt ?? undefined;
         const postData: CreatePost = {
           ...data,
@@ -2948,6 +3126,9 @@ export function createPostService(
         const preparedBody = normalizedBody
           ? tryPreparePostBodyHtml(existing.id, normalizedBody)
           : null;
+        if (preparedBody && !preparedBody.ok) {
+          throw new ValidationError(INVALID_POST_BODY_MESSAGE);
+        }
         updatedBody = preparedBody?.ok ? preparedBody.body : normalizedBody;
         updates.body = updatedBody;
         updates.bodyHtml = preparedBody?.ok
@@ -3486,7 +3667,7 @@ export function createPostService(
         .select()
         .from(posts)
         .where(and(eq(posts.siteId, siteId), eq(posts.threadId, rootId)))
-        .orderBy(posts.createdAt, posts.id);
+        .orderBy(...threadOrder());
 
       return hydratePosts(rows);
     },
@@ -4020,10 +4201,9 @@ export function createPostService(
         .select({
           id: posts.id,
           threadId: posts.threadId,
-          createdAt: posts.createdAt,
           previewRank: sql<number>`CAST(ROW_NUMBER() OVER (
             PARTITION BY ${posts.threadId}
-            ORDER BY ${posts.createdAt}, ${posts.id}
+            ORDER BY ${sql.join(threadOrder(), sql`, `)}
           ) AS INTEGER)`.as("preview_rank"),
         })
         .from(posts)
@@ -4041,15 +4221,10 @@ export function createPostService(
         .select({
           id: rankedReplies.id,
           threadId: rankedReplies.threadId,
-          createdAt: rankedReplies.createdAt,
         })
         .from(rankedReplies)
         .where(lte(rankedReplies.previewRank, previewCount))
-        .orderBy(
-          rankedReplies.threadId,
-          rankedReplies.createdAt,
-          rankedReplies.id,
-        );
+        .orderBy(rankedReplies.threadId, sql`${rankedReplies.previewRank}`);
 
       const hydratedPosts = await hydratePostsById(
         rankedRows.map((row) => row.id),
@@ -4079,11 +4254,11 @@ export function createPostService(
           threadId: posts.threadId,
           firstReplyRank: sql<number>`CAST(ROW_NUMBER() OVER (
             PARTITION BY ${posts.threadId}
-            ORDER BY ${posts.createdAt}, ${posts.id}
+            ORDER BY ${sql.join(threadOrder(), sql`, `)}
           ) AS INTEGER)`.as("first_reply_rank"),
           latestReplyRank: sql<number>`CAST(ROW_NUMBER() OVER (
             PARTITION BY ${posts.threadId}
-            ORDER BY ${posts.createdAt} DESC, ${posts.id} DESC
+            ORDER BY ${sql.join(threadOrder("desc"), sql`, `)}
           ) AS INTEGER)`.as("latest_reply_rank"),
           totalReplyCount: sql<number>`CAST(COUNT(*) OVER (
             PARTITION BY ${posts.threadId}
@@ -4268,7 +4443,7 @@ export function createPostService(
       const threadPosition = sql<number>`CAST(
         row_number() OVER (
           PARTITION BY ${posts.threadId}
-          ORDER BY ${posts.createdAt}, ${posts.id}
+          ORDER BY ${sql.join(threadOrder(), sql`, `)}
         ) - 1 AS INTEGER
       )`.as("thread_position");
       const threadPostCount = sql<number>`CAST(
@@ -4609,7 +4784,7 @@ export function createPostService(
           .select()
           .from(posts)
           .where(and(...conditions))
-          .orderBy(posts.threadId, posts.createdAt, posts.id);
+          .orderBy(posts.threadId, ...threadOrder());
       });
 
       for (const post of await hydratePosts(rows)) {
@@ -4642,7 +4817,7 @@ export function createPostService(
             ...(options?.includeDrafts ? [] : [eq(posts.status, "published")]),
           ),
         )
-        .orderBy(posts.threadId, desc(posts.createdAt), desc(posts.id));
+        .orderBy(posts.threadId, ...threadOrder("desc"));
 
       for (const row of rows) {
         if (!result.has(row.threadId)) {

package/src/services/site-admin.ts

@@ -29,11 +29,7 @@ import {
 } from "../ui/font-themes.js";
 import type { Site, SiteDomain } from "../types.js";
 import { createCollectionService } from "./collection.js";
-// Note: `./export.js` is loaded lazily inside `exportManagedSite` because it
-// pulls in Vite-specific `?raw` asset imports (CSS/HTML/JS templates) at
-// module-load time. Importing it eagerly here would force every consumer of
-// `services/index.ts` — including Node-only dev scripts run under tsx — to
-// resolve those Vite-only imports just to construct the services bundle.
+import { createExportService } from "./export.js";
 import { createMediaService } from "./media.js";
 import { createNavItemService } from "./navigation.js";
 import { createPathService } from "./path.js";
@@ -84,7 +80,8 @@ export interface ExportManagedSiteDeps {
 
 export interface ManagedSiteExportResult {
   filename: string;
-  zip: Uint8Array;
+  /** The site's Hugo export as a ZIP stream; see `generateHugoSite`. */
+  zip: ReadableStream<Uint8Array>;
 }
 
 export interface ManagedSiteMediaUsageResult {
@@ -810,7 +807,6 @@ export function createSiteAdminService(
       );
       const navItemList = await navItems.list();
       const appleTouchKey = allSettings[SETTINGS_KEYS.SITE_FAVICON_APPLE_TOUCH];
-      const { createExportService } = await import("./export.js");
       const exportService = createExportService(
         {
           collections,

package/src/services/site.ts

@@ -17,8 +17,18 @@ export interface SiteLookupResult {
   domain: SiteDomain | null;
 }
 
+/**
+ * Where a single-site install's row and domain come from. Every field applies
+ * only when the site is created; an existing site keeps its own.
+ */
 export interface EnsureSingleSiteOptions {
   host?: string | null;
+  /**
+   * The id to create the site with, instead of a random one. A deployment
+   * that restores a snapshot on every start gives the site the snapshot's id,
+   * so media URLs — which carry the site id — stay the same across rebuilds.
+   */
+  id?: string;
   key?: string;
   pathPrefix?: string | null;
 }
@@ -131,6 +141,9 @@ function toSiteDomain(row: typeof _sqliteSiteDomains.$inferSelect): SiteDomain {
 
 export const TRANSIENT_SINGLE_SITE_ID = "sit_pending";
 
+/** Joined-row ceiling for the single-site read — see `loadSingleSiteWithDomain`. */
+const SINGLE_SITE_JOIN_SCAN_LIMIT = 25;
+
 export function createTransientSite(key = "default"): Site {
   return {
     id: TRANSIENT_SINGLE_SITE_ID,
@@ -175,6 +188,49 @@ export function createSiteService(
     return rows[0];
   }
 
+  /**
+   * The instance's one site together with its oldest domain, in one read.
+   *
+   * Every request resolves the site before it can do anything else, so the two
+   * reads this replaces sat at the head of the chain, one waiting on the other.
+   * Joining them keeps the domain ordering the separate read had — oldest
+   * first — and the multi-site guard that read carried.
+   *
+   * The limit bounds the scan, but it now bounds *joined* rows rather than
+   * sites, so one site with many domains could in principle fill the window and
+   * hide a second site from the guard. That case falls back to
+   * {@link loadSingleSiteRow}, which bounds sites; a single-site install has a
+   * handful of domains, so it is not reached in practice.
+   */
+  async function loadSingleSiteWithDomain(): Promise<{
+    site: typeof sites.$inferSelect | undefined;
+    domain: typeof siteDomains.$inferSelect | undefined;
+  }> {
+    const rows = await db
+      .select({ site: sites, domain: siteDomains })
+      .from(sites)
+      .leftJoin(siteDomains, eq(siteDomains.siteId, sites.id))
+      .orderBy(asc(sites.createdAt), asc(siteDomains.createdAt))
+      .limit(SINGLE_SITE_JOIN_SCAN_LIMIT);
+
+    const distinctSites = new Map<string, typeof sites.$inferSelect>();
+    for (const row of rows) {
+      distinctSites.set(row.site.id, row.site);
+    }
+    if (distinctSites.size > 1) {
+      throw createSingleSiteModeConfigurationError([...distinctSites.values()]);
+    }
+
+    // Only one site is in play, so the first non-null domain is its oldest.
+    const domain = rows.find((row) => row.domain)?.domain ?? undefined;
+
+    if (rows.length === SINGLE_SITE_JOIN_SCAN_LIMIT) {
+      return { site: await loadSingleSiteRow(), domain };
+    }
+
+    return { site: rows[0]?.site, domain };
+  }
+
   return {
     async list() {
       const rows = await db.select().from(sites).orderBy(asc(sites.createdAt));
@@ -223,7 +279,12 @@ export function createSiteService(
 
     async resolveSingleSite(options = {}) {
       const shouldCreateIfMissing = options.createIfMissing ?? false;
-      const existingRow = await loadSingleSiteRow();
+      // The domain is only read when the caller names a host, so only that
+      // path pays for the join.
+      const loaded = options.host
+        ? await loadSingleSiteWithDomain()
+        : { site: await loadSingleSiteRow(), domain: undefined };
+      const existingRow = loaded.site;
       const timestamp = now();
       const created = existingRow
         ? existingRow
@@ -232,7 +293,7 @@ export function createSiteService(
               await db
                 .insert(sites)
                 .values({
-                  id: createEntityId("site"),
+                  id: options.id ?? createEntityId("site"),
                   key: options.key?.trim() || "default",
                   status: "active",
                   createdAt: timestamp,
@@ -249,35 +310,26 @@ export function createSiteService(
         };
       }
 
-      let domainRow: typeof siteDomains.$inferSelect | undefined;
-
-      if (options.host) {
-        const domainRows = await db
-          .select()
-          .from(siteDomains)
-          .where(eq(siteDomains.siteId, created.id))
-          .orderBy(asc(siteDomains.createdAt))
-          .limit(1);
-
-        domainRow = domainRows[0];
-
-        if (!domainRow && shouldCreateIfMissing) {
-          domainRow = (
-            await db
-              .insert(siteDomains)
-              .values({
-                id: createEntityId("siteDomain"),
-                siteId: created.id,
-                host: options.host,
-                pathPrefix: options.pathPrefix?.trim() || null,
-                kind: "primary",
-                redirectToPrimary: true,
-                createdAt: timestamp,
-                updatedAt: timestamp,
-              })
-              .returning()
-          )[0];
-        }
+      // A site that was just inserted has no domains yet, whatever the read
+      // above returned.
+      let domainRow = existingRow ? loaded.domain : undefined;
+
+      if (options.host && !domainRow && shouldCreateIfMissing) {
+        domainRow = (
+          await db
+            .insert(siteDomains)
+            .values({
+              id: createEntityId("siteDomain"),
+              siteId: created.id,
+              host: options.host,
+              pathPrefix: options.pathPrefix?.trim() || null,
+              kind: "primary",
+              redirectToPrimary: true,
+              createdAt: timestamp,
+              updatedAt: timestamp,
+            })
+            .returning()
+        )[0];
       }
 
       return {

package/src/styles/ui.css

@@ -2346,6 +2346,13 @@
     margin-top: 0.65rem;
   }
 
+  /* A preview is a block of image, not a line of text: commentary set 0.65rem
+     under it reads as a caption. Give it the same air the title leaves above
+     the preview, so the image sits between the two rather than on the body. */
+  [data-format="link"] .link-preview + [data-post-body] {
+    margin-top: 1.4rem;
+  }
+
   .feed-link-domain {
     display: inline-flex;
     align-items: center;
@@ -5354,7 +5361,6 @@
   .home-branding-credit {
     margin-top: var(--space-xl);
     padding-bottom: var(--space-xl);
-    text-align: center;
     color: var(--site-text-secondary);
     font-size: var(--type-base);
   }

package/src/types/app-context.ts

@@ -8,6 +8,7 @@
 
 import type { Hono } from "hono";
 import type { Services } from "../services/index.js";
+import type { ResolvedPath } from "../services/path.js";
 import type { HostedHandoffService } from "../services/hosted-handoff.js";
 import type { Auth } from "../auth.js";
 import type { AppConfig } from "./config.js";
@@ -40,6 +41,21 @@ export interface AppVariables {
   storage: StorageDriver | null;
   publicRequestUrl: string;
   publicPath: string;
+  /**
+   * The `path_registry` row for this request's own path, read once by the
+   * stored-redirect middleware so the catch-all route does not resolve the same
+   * address a second time.
+   *
+   * `record` is null when nothing is registered at `path`, which is a real
+   * answer and worth reusing. The whole field is absent when the middleware
+   * skipped the lookup (API and asset paths) — readers must fall back to
+   * `services.paths.resolve` rather than treat absence as "nothing registered".
+   *
+   * `path` is the stored form the lookup used, so a reader compares its own
+   * normalized path against it before trusting the record: a language view
+   * strips its prefix and is asking about a different address.
+   */
+  pathLookup?: { path: string; record: ResolvedPath | null };
   /**
    * Cached session for the current request. `null` when unauthenticated or
    * when the session lookup errored. Populated by `attachSession` middleware.

package/src/types/bindings.ts

@@ -28,6 +28,11 @@ export interface Bindings {
   R2?: R2Bucket;
   NODE_DATABASE?: NodeDatabaseBinding;
   NODE_SQLITE?: BetterSqlite3.Database;
+  /**
+   * When this Node process started serving, in Unix seconds. Set by the
+   * request handler; a Worker has no process to date.
+   */
+  NODE_STARTED_AT?: number;
   SITE_ORIGIN?: EnvBindingValue;
   SITE_PATH_PREFIX?: EnvBindingValue;
   DEFAULT_THEME?: EnvBindingValue;