@agent-native/core-corpus 0.201.0-nightly-20261005153421 → 0.201.0

package/corpus/templates/content/app/lib/files-navigation.ts

@@ -1,11 +1,35 @@
+import { callActionWithRetry } from "@agent-native/core/client/hooks";
 import type {
-  ContentDatabaseNavigationSort,
+  ContentDatabaseNavigationPageResponse,
   ContentDatabasePersonalViewOverrides,
+  ContentDatabaseUnavailableResponse,
   ContentSidebarViewOrder,
 } from "@shared/api";
+import {
+  useQuery,
+  useQueryClient,
+  type QueryClient,
+} from "@tanstack/react-query";
+import { useEffect, useRef } from "react";
 
 export const FILES_NAVIGATION_PAGE_SIZE = 20;
 
+// Most expanded folders one read asks for; the server caps what it returns.
+const MAX_EXPANDED_IDS_PER_READ = 100;
+const pendingExpansionReads = new WeakMap<QueryClient, Set<string>>();
+
+/**
+ * The folders the Files tree draws open, most important first: both caps on
+ * the folders one read opens keep the first ones, so the open page's
+ * ancestors come before the folders a person expanded.
+ */
+export function openFilesFolderIds(
+  activeAncestorIds: Iterable<string>,
+  expandedDocumentIds: Iterable<string>,
+): ReadonlySet<string> {
+  return new Set([...activeAncestorIds, ...expandedDocumentIds]);
+}
+
 /** The Files tree order a person chose, as the paged navigation query reads it. */
 export function filesNavigationOrder(
   overrides: ContentDatabasePersonalViewOverrides | null | undefined,
@@ -19,22 +43,170 @@ export function filesNavigationOrder(
 }
 
 // Every reader of one Files branch must build the same params so the sidebar
-// tree and breadcrumb menus share one cached request per page.
+// tree and breadcrumb menus share one cached request per page. The server
+// orders a branch by the person's saved view, so the order is not part of
+// the key: a branch can be read before that view arrives.
 export function filesNavigationPageParams(args: {
   databaseId: string;
   parentId: string | null;
-  sort: ContentDatabaseNavigationSort;
-  viewId?: string;
   cursor?: string;
 }) {
   return {
     databaseId: args.databaseId,
     limit: FILES_NAVIGATION_PAGE_SIZE,
-    navigation: {
-      parentId: args.parentId,
-      sort: args.sort,
-      viewId: args.viewId,
-      cursor: args.cursor,
-    },
+    navigation: { parentId: args.parentId, cursor: args.cursor },
   };
 }
+
+export type FilesNavigationPageParams = ReturnType<
+  typeof filesNavigationPageParams
+>;
+
+export function filesNavigationQueryKey(params: FilesNavigationPageParams) {
+  return ["action", "query-content-database-items", params] as const;
+}
+
+type FilesNavigationRead =
+  | ContentDatabaseNavigationPageResponse
+  | ContentDatabaseUnavailableResponse;
+
+/**
+ * Reads one Files page and asks for any expanded folders that do not have a
+ * cached page yet, so opening a cached root can still load its new branches.
+ */
+export async function readFilesNavigationPage(
+  queryClient: QueryClient,
+  params: FilesNavigationPageParams,
+  expanded: Iterable<string>,
+  signal?: AbortSignal,
+): Promise<FilesNavigationRead> {
+  const expand = [...expanded]
+    .filter((parentId) => {
+      const key = filesNavigationQueryKey(
+        filesNavigationPageParams({
+          databaseId: params.databaseId,
+          parentId,
+        }),
+      );
+      return queryClient.getQueryData(key) === undefined;
+    })
+    .slice(0, MAX_EXPANDED_IDS_PER_READ);
+  const expansionKey =
+    expand.length > 0 ? JSON.stringify([params.databaseId, expand]) : null;
+  let pending: Set<string> | undefined;
+  if (expansionKey) {
+    pending = pendingExpansionReads.get(queryClient);
+    if (!pending) {
+      pending = new Set();
+      pendingExpansionReads.set(queryClient, pending);
+    }
+    pending.add(expansionKey);
+  }
+  try {
+    const response = await callActionWithRetry<FilesNavigationRead>(
+      "query-content-database-items",
+      expand.length
+        ? { ...params, navigation: { ...params.navigation, expand } }
+        : params,
+      { method: "GET", signal },
+    );
+    if ("available" in response) return response;
+    // A folder left out of `branches`, whether the cap dropped it
+    // (`branchesTruncated`) or it has no children to show, is not seeded as
+    // empty: it reads its own page when it draws.
+    const { branches, branchesTruncated, ...page } = response;
+    for (const [parentId, branch] of Object.entries(branches ?? {})) {
+      const key = filesNavigationQueryKey(
+        filesNavigationPageParams({
+          databaseId: params.databaseId,
+          parentId,
+        }),
+      );
+      // A folder that already has its own page keeps it; that read is the
+      // one its later changes refresh.
+      if (queryClient.getQueryData(key) === undefined) {
+        queryClient.setQueryData(key, branch);
+      }
+    }
+    return page;
+  } finally {
+    if (expansionKey && pending) pending.delete(expansionKey);
+  }
+}
+
+function isExpansionReadPending(
+  queryClient: QueryClient,
+  databaseId: string,
+  expanded: Iterable<string>,
+) {
+  const expand = [...expanded]
+    .filter((parentId) => {
+      const key = filesNavigationQueryKey(
+        filesNavigationPageParams({ databaseId, parentId }),
+      );
+      return queryClient.getQueryData(key) === undefined;
+    })
+    .slice(0, MAX_EXPANDED_IDS_PER_READ);
+  if (expand.length === 0) return false;
+  return (
+    pendingExpansionReads
+      .get(queryClient)
+      ?.has(JSON.stringify([databaseId, expand])) ?? false
+  );
+}
+
+export function useFilesNavigationPage(
+  params: FilesNavigationPageParams,
+  expanded: ReadonlySet<string>,
+) {
+  const queryClient = useQueryClient();
+  const expansionKey = JSON.stringify([
+    params.databaseId,
+    params.navigation.parentId,
+    params.navigation.cursor ?? null,
+    [...expanded],
+  ]);
+  const rootReadExpansion = useRef<string | null>(null);
+  const query = useQuery({
+    queryKey: filesNavigationQueryKey(params),
+    queryFn: ({ signal }) => {
+      rootReadExpansion.current = expansionKey;
+      return readFilesNavigationPage(queryClient, params, expanded, signal);
+    },
+    retry: false,
+  });
+  useEffect(() => {
+    if (
+      !query.data ||
+      "available" in query.data ||
+      query.isFetching ||
+      isExpansionReadPending(queryClient, params.databaseId, expanded) ||
+      rootReadExpansion.current === expansionKey
+    ) {
+      return;
+    }
+    const hasMissingBranch = [...expanded].some((parentId) => {
+      const key = filesNavigationQueryKey(
+        filesNavigationPageParams({
+          databaseId: params.databaseId,
+          parentId,
+        }),
+      );
+      return queryClient.getQueryData(key) === undefined;
+    });
+    if (!hasMissingBranch) {
+      rootReadExpansion.current = expansionKey;
+      return;
+    }
+    void query.refetch();
+  }, [
+    expanded,
+    expansionKey,
+    params,
+    query.data,
+    query.isFetching,
+    query.refetch,
+    queryClient,
+  ]);
+  return query;
+}

package/corpus/templates/content/app/lib/files-root-hint.ts

@@ -1,14 +1,16 @@
-import { callAction } from "@agent-native/core/client/hooks";
-import type { ContentDatabaseNavigationSort } from "@shared/api";
 import type { QueryClient } from "@tanstack/react-query";
 
-import { filesNavigationPageParams } from "@/lib/files-navigation";
+import {
+  filesNavigationPageParams,
+  filesNavigationQueryKey,
+  readFilesNavigationPage,
+} from "@/lib/files-navigation";
 
-// The Files tree's root page is keyed by the space's Files database and the
-// personal view's order, which arrive from two other reads. The inputs this
-// browser last used for the same person in the same active organization let
-// the root page start alongside those reads; when they turn out different,
-// the tree reads again with the confirmed ones and the early read is unused.
+// The Files tree's root page is keyed by the space's Files database, which
+// arrives from another read. The database this browser last used for the same
+// person in the same active organization lets the root page start alongside
+// that read; when it turns out different, the tree reads again with the
+// confirmed one and the early read is unused.
 const FILES_ROOT_HINT_STORAGE_KEY = "content-sidebar-files-root-v1";
 
 export function filesRootHintScope(
@@ -19,11 +21,7 @@ export function filesRootHintScope(
   return account ? JSON.stringify([account, orgId ?? null]) : null;
 }
 
-export type PagedFilesRoot = {
-  databaseId: string;
-  sort: ContentDatabaseNavigationSort;
-  viewId?: string;
-};
+export type PagedFilesRoot = { databaseId: string };
 
 export function readPagedFilesRootHint(scope: string): PagedFilesRoot | null {
   let raw: string | null;
@@ -35,21 +33,11 @@ export function readPagedFilesRootHint(scope: string): PagedFilesRoot | null {
   }
   if (!raw) return null;
   try {
-    const hint = JSON.parse(raw) as Partial<PagedFilesRoot> & {
-      scope?: unknown;
-    };
-    if (
-      hint.scope !== scope ||
-      typeof hint.databaseId !== "string" ||
-      typeof hint.sort !== "string"
-    ) {
+    const hint = JSON.parse(raw) as { scope?: unknown; databaseId?: unknown };
+    if (hint.scope !== scope || typeof hint.databaseId !== "string") {
       return null;
     }
-    return {
-      databaseId: hint.databaseId,
-      sort: hint.sort,
-      ...(typeof hint.viewId === "string" ? { viewId: hint.viewId } : {}),
-    };
+    return { databaseId: hint.databaseId };
   } catch {
     // coercion-ok: a malformed hint is ignored and replaced by the next write.
     return null;
@@ -67,17 +55,17 @@ export function rememberPagedFilesRoot(scope: string, root: PagedFilesRoot) {
   }
 }
 
+/** Starts the root page, with the first pages of `expanded` folders. */
 export function prefetchPagedFilesRoot(
   queryClient: QueryClient,
   root: PagedFilesRoot,
+  expanded: readonly string[] = [],
 ) {
-  const args = filesNavigationPageParams({ ...root, parentId: null });
+  const params = filesNavigationPageParams({ ...root, parentId: null });
   void queryClient.prefetchQuery({
-    queryKey: ["action", "query-content-database-items", args],
+    queryKey: filesNavigationQueryKey(params),
     queryFn: ({ signal }) =>
-      callAction("query-content-database-items", args, {
-        method: "GET",
-        signal,
-      }),
+      readFilesNavigationPage(queryClient, params, expanded, signal),
+    retry: false,
   });
 }

package/corpus/templates/content/app/lib/page-startup-hints.ts

@@ -0,0 +1,108 @@
+import type {
+  DocumentEditorIconRow,
+  DocumentEditorShape,
+} from "@/components/editor/document-editor-layout";
+
+import { LAST_LOCATION_HINT_STORAGE_KEY } from "./last-location-hint";
+
+// Before a page loads, nothing says what it will draw: whether it has an icon,
+// whether this person can edit it, whether it is a collection, or whether its
+// open comments hold the review margin open. What this browser last drew for a
+// page lets its placeholder hold the same boxes. Only page ids and these flags
+// are kept, and only for pages that differ from the default.
+const PAGE_ICON_ROWS_STORAGE_KEY = "content-page-icon-rows-v1";
+const PAGE_SHAPES_STORAGE_KEY = "content-page-shapes-v1";
+const MAX_REMEMBERED_PAGES = 200;
+
+export const STARTUP_PAGE_ICON_ROW_ATTRIBUTE = "data-content-page-icon-row";
+export const STARTUP_PAGE_SHAPE_ATTRIBUTE = "data-content-page-shape";
+
+const REMEMBERED_SHAPES = [
+  "review",
+  "database",
+  "database-constrained",
+] as const satisfies readonly DocumentEditorShape[];
+
+function readStoredHints(key: string): Record<string, unknown> {
+  try {
+    const raw = localStorage.getItem(key);
+    const parsed: unknown = raw ? JSON.parse(raw) : null;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : {};
+  } catch {
+    // coercion-ok: an unreadable hint only means the page may move once.
+    return {};
+  }
+}
+
+function rememberHint(
+  key: string,
+  documentId: string,
+  value: string,
+  defaultValue: string,
+) {
+  const hints = readStoredHints(key);
+  if (value === defaultValue && hints[documentId] === undefined) return;
+  delete hints[documentId];
+  if (value !== defaultValue) hints[documentId] = value;
+  const ids = Object.keys(hints);
+  const overflow = Math.max(0, ids.length - MAX_REMEMBERED_PAGES);
+  for (const id of ids.slice(0, overflow)) delete hints[id];
+  try {
+    localStorage.setItem(key, JSON.stringify(hints));
+  } catch {
+    // coercion-ok: without storage the next load holds the default boxes.
+  }
+}
+
+export function readPageIconRowHint(documentId: string): DocumentEditorIconRow {
+  const row = readStoredHints(PAGE_ICON_ROWS_STORAGE_KEY)[documentId];
+  return row === "icon" || row === "none" ? row : "add";
+}
+
+export function rememberPageIconRow(
+  documentId: string,
+  row: DocumentEditorIconRow,
+) {
+  rememberHint(PAGE_ICON_ROWS_STORAGE_KEY, documentId, row, "add");
+}
+
+export function readPageShapeHint(documentId: string): DocumentEditorShape {
+  const shape = readStoredHints(PAGE_SHAPES_STORAGE_KEY)[documentId];
+  return REMEMBERED_SHAPES.find((remembered) => remembered === shape) ?? "page";
+}
+
+// A loaded page knows whether it is a collection; the hint still says which
+// boxes it last drew below the title.
+export function readDocumentShapeHint(document: {
+  id: string;
+  database?: unknown;
+}): DocumentEditorShape {
+  const shape = readPageShapeHint(document.id);
+  if (document.database) {
+    return shape === "database-constrained" ? shape : "database";
+  }
+  return shape === "review" ? shape : "page";
+}
+
+export function rememberPageShape(
+  documentId: string,
+  shape: DocumentEditorShape,
+) {
+  rememberHint(PAGE_SHAPES_STORAGE_KEY, documentId, shape, "page");
+}
+
+// Runs in <head> before the first paint, so the server-rendered placeholder
+// holds the boxes a page last drew. The app may sit under a base path; on
+// `/home`, use the last-location id unless the URL selects a specific space.
+// coercion-ok: an unreadable hint only means the page may move once.
+export const CONTENT_STARTUP_PAGE_HINTS_SCRIPT = `(function(){try{function h(k){try{return JSON.parse(localStorage.getItem(k)||"{}")[id]}catch(e){}}var p=location.pathname.split("/").filter(Boolean),i=p.indexOf("page"),id=i>=0&&p[i+1]?decodeURIComponent(p[i+1]):null;if(!id&&p[p.length-1]==="home"&&!/[?&]spaceId=/.test(location.search))id=(JSON.parse(localStorage.getItem(${JSON.stringify(
+  LAST_LOCATION_HINT_STORAGE_KEY,
+)})||"null")||{}).documentId;if(typeof id!=="string"||!id)return;var d=document.documentElement,r=h(${JSON.stringify(
+  PAGE_ICON_ROWS_STORAGE_KEY,
+)}),s=h(${JSON.stringify(PAGE_SHAPES_STORAGE_KEY)});if(r==="icon"||r==="none")d.setAttribute(${JSON.stringify(
+  STARTUP_PAGE_ICON_ROW_ATTRIBUTE,
+)},r);if(${JSON.stringify(REMEMBERED_SHAPES)}.indexOf(s)>=0)d.setAttribute(${JSON.stringify(
+  STARTUP_PAGE_SHAPE_ATTRIBUTE,
+)},s)}catch(e){}})();`; // coercion-ok: without storage the shell holds the default boxes.

package/corpus/templates/content/app/lib/private-link-redirect.ts

@@ -0,0 +1,25 @@
+import { safeJsonForHtml } from "@agent-native/core/shared";
+
+export const PRIVATE_LINK_REDIRECT_ATTRIBUTE =
+  "data-content-private-link-redirect";
+
+// Tailwind only finds whole class strings, so the attribute is spelled out
+// here; a test keeps it equal to PRIVATE_LINK_REDIRECT_ATTRIBUTE.
+export const HIDDEN_WHILE_PRIVATE_LINK_REDIRECTS =
+  "[html[data-content-private-link-redirect]_&]:invisible";
+
+// Every visitor gets the same cached share page, so it can't know whether this
+// browser may open the document. Browsers leave for the app page before first
+// paint, which opens the document or says why it can't; the private notice is
+// for fetchers that don't run scripts.
+export function privateDocumentRedirectScript(pageHref: string) {
+  return `document.documentElement.setAttribute(${JSON.stringify(
+    PRIVATE_LINK_REDIRECT_ATTRIBUTE,
+  )},"");location.replace(${safeJsonForHtml(pageHref)});`;
+}
+
+// The script has already started the move, and starting it again cancels the
+// request in flight.
+export function privateLinkRedirectStarted() {
+  return document.documentElement.hasAttribute(PRIVATE_LINK_REDIRECT_ATTRIBUTE);
+}

package/corpus/templates/content/app/lib/sidebar-layout-hint.ts

@@ -7,12 +7,15 @@ import {
 // that land in any order. What this browser last drew for the same person,
 // organization, and space lets the first frame reserve each section at that
 // size, so later rows fill in place instead of pushing the sections below.
-// Only counts and section settings are kept, never titles.
+// The Files folders that were open are kept by ID, so the next load reads
+// them with the tree. Only counts, IDs, and section settings are kept, never
+// titles.
 const SIDEBAR_LAYOUT_HINT_STORAGE_KEY = "content-sidebar-layout-v1";
 
 // Rows each section shows before "Show more", and the most a hint reserves.
 export const SIDEBAR_SECTION_ROW_LIMIT = 5;
 const MAX_HINTED_FILES_ROWS = 100;
+const MAX_HINTED_FILES_BRANCHES = 32;
 
 export type SidebarRowsHint = { rows: number; more: boolean };
 
@@ -21,6 +24,8 @@ export type SidebarLayoutHint = {
   pinned?: SidebarRowsHint;
   recent?: SidebarRowsHint;
   files?: SidebarRowsHint;
+  /** Rows each open Files folder drew, by folder document ID. */
+  branches?: Record<string, SidebarRowsHint>;
 };
 
 function parseRows(value: unknown, max: number): SidebarRowsHint | undefined {
@@ -32,6 +37,33 @@ function parseRows(value: unknown, max: number): SidebarRowsHint | undefined {
   return { rows: Math.min(rows, max), more: more === true };
 }
 
+// Folders are stored oldest first, so the cap keeps the most recently drawn.
+function parseBranches(
+  value: unknown,
+): Record<string, SidebarRowsHint> | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  return Object.fromEntries(
+    Object.entries(value)
+      .slice(-MAX_HINTED_FILES_BRANCHES)
+      .flatMap(([documentId, rows]) => {
+        const parsed = parseRows(rows, MAX_HINTED_FILES_ROWS);
+        return parsed ? [[documentId, parsed]] : [];
+      }),
+  );
+}
+
+/** Open folders with `documentId` moved last, as the most recently drawn. */
+export function withShownFilesBranch(
+  branches: Readonly<Record<string, SidebarRowsHint>> | undefined,
+  documentId: string,
+  rows: SidebarRowsHint,
+): Record<string, SidebarRowsHint> {
+  const { [documentId]: _previous, ...others } = branches ?? {};
+  return { ...others, [documentId]: rows };
+}
+
 function readStoredHint(): {
   scope?: unknown;
   spaceId?: unknown;
@@ -75,6 +107,7 @@ export function readSidebarLayoutHint(
     pinned: parseRows(stored.hint.pinned, SIDEBAR_SECTION_ROW_LIMIT),
     recent: parseRows(stored.hint.recent, SIDEBAR_SECTION_ROW_LIMIT),
     files: parseRows(stored.hint.files, MAX_HINTED_FILES_ROWS),
+    branches: parseBranches(stored.hint.branches),
   };
 }
 

package/corpus/templates/content/app/lib/startup-timing.ts

@@ -14,6 +14,8 @@ export const PAINTED_MARK_SUFFIX = ":painted";
 export type StartupAnchor =
   | "title"
   | "body"
+  | "database-tabs"
+  | "database-table"
   | "sidebar-space"
   | "sidebar-search"
   | "sidebar-section-pinned"

package/corpus/templates/content/app/root.tsx

@@ -66,6 +66,7 @@ import { CONTENT_COMMAND_MENU_OPEN_EVENT } from "./lib/content-command-menu";
 import { isPersonalLanding } from "./lib/content-landing";
 import { readLastLocationHintForAnyAccount } from "./lib/last-location-hint";
 import { CONTENT_STARTUP_PAGE_ICON_ROW_SCRIPT } from "./lib/page-icon-row-hint";
+import { CONTENT_STARTUP_PAGE_HINTS_SCRIPT } from "./lib/page-startup-hints";
 
 import stylesheet from "./global.css?url";
 import katexStylesheet from "katex/dist/katex.min.css?url";
@@ -216,7 +217,8 @@ export function Layout({ children }: { children: React.ReactNode }) {
           dangerouslySetInnerHTML={{
             __html:
               CONTENT_STARTUP_SIDEBAR_SCRIPT +
-              CONTENT_STARTUP_PAGE_ICON_ROW_SCRIPT,
+              CONTENT_STARTUP_PAGE_ICON_ROW_SCRIPT +
+              CONTENT_STARTUP_PAGE_HINTS_SCRIPT,
           }}
         />
         <meta name="theme-color" content="#10B981" />

package/corpus/templates/content/app/routes/_app.home.tsx

@@ -28,17 +28,17 @@ import {
   startPageOpenDocumentReads,
 } from "@/hooks/use-documents";
 import { useLastLocationTitleHint } from "@/hooks/use-optimistic-document-title";
-import {
-  isPersonalLanding,
-  readContentLandingRecovery,
-} from "@/lib/content-landing";
+import { isPersonalLanding } from "@/lib/content-landing";
 import {
   landingOptimisticTitle,
   stashLandingTitleHint,
 } from "@/lib/document-title-hint";
 import { filesRootHintScope } from "@/lib/files-root-hint";
 import { readLastLocationHint } from "@/lib/last-location-hint";
-import { readPageIconRowHint } from "@/lib/page-icon-row-hint";
+import {
+  readPageIconRowHint,
+  readPageShapeHint,
+} from "@/lib/page-startup-hints";
 
 const SEO_TITLE = "Content - Open Source, agent-friendly Obsidian alternative";
 const SEO_DESCRIPTION =
@@ -119,8 +119,6 @@ export default function HomeRoute() {
   const lastLocationHint = useLastLocationTitleHint();
   const lastLocationHintRef = useRef(lastLocationHint);
   lastLocationHintRef.current = lastLocationHint;
-  const recoveredDocumentId =
-    readContentLandingRecovery(location.state)?.unavailableDocumentId ?? null;
   const queryClient = useQueryClient();
   const { session } = useSession();
   const scope = filesRootHintScope(session?.email, session?.orgId);
@@ -181,9 +179,7 @@ export default function HomeRoute() {
         void navigate(contentRecentHref(result.target), { replace: true });
         return;
       }
-      if (recoveredDocumentId) {
-        toast.info(t("landing.requestedPageUnavailable"));
-      } else if (result.fallbackReason === "saved-document-unavailable") {
+      if (result.fallbackReason === "saved-document-unavailable") {
         toast.info(t("landing.previousPageUnavailable"));
       }
       const hint = lastLocationHintRef.current;
@@ -201,15 +197,7 @@ export default function HomeRoute() {
     } catch (error) {
       console.error("Failed to resolve the Content landing page", error);
     }
-  }, [
-    location.hash,
-    location.search,
-    navigate,
-    recoveredDocumentId,
-    resolveLanding,
-    spaceId,
-    t,
-  ]);
+  }, [location.hash, location.search, navigate, resolveLanding, spaceId, t]);
 
   useEffect(() => {
     void openLanding();
@@ -249,6 +237,9 @@ export default function HomeRoute() {
         iconRow={
           likelyDocumentId ? readPageIconRowHint(likelyDocumentId) : undefined
         }
+        shape={
+          likelyDocumentId ? readPageShapeHint(likelyDocumentId) : undefined
+        }
       />
     </>
   );

package/corpus/templates/content/app/routes/p.$id.tsx

@@ -28,6 +28,11 @@ import type {
 import { data, redirect, useLoaderData } from "react-router";
 
 import { VisualEditor } from "@/components/editor/VisualEditor";
+import {
+  HIDDEN_WHILE_PRIVATE_LINK_REDIRECTS,
+  privateDocumentRedirectScript,
+  privateLinkRedirectStarted,
+} from "@/lib/private-link-redirect";
 
 import { getDb, schema } from "../../server/db";
 import {
@@ -93,7 +98,7 @@ export async function loader({ params, request }: LoaderFunctionArgs) {
   const userEmail = getRequestUserEmail();
   if (userEmail) {
     const access = await resolveAccess("document", id);
-    if (access) throw redirect(withBase(`/page/${id}`));
+    if (access) throw redirect(withBase(`/page/${encodeURIComponent(id)}`));
   }
 
   const [doc] = await getDb()
@@ -330,13 +335,24 @@ function PrivateDocumentNotice({
   origin?: string;
 }) {
   const t = useT();
+  const pageHref = id
+    ? `${basePath ?? ""}/page/${encodeURIComponent(id)}`
+    : null;
   useEffect(() => {
-    if (!id) return;
-    window.location.replace(`${basePath ?? ""}/page/${id}`);
-  }, [id, basePath]);
+    if (!pageHref || privateLinkRedirectStarted()) return;
+    window.location.replace(pageHref);
+  }, [pageHref]);
 
   return (
     <main className="min-h-screen bg-background text-foreground">
+      {pageHref ? (
+        <script
+          suppressHydrationWarning
+          dangerouslySetInnerHTML={{
+            __html: privateDocumentRedirectScript(pageHref),
+          }}
+        />
+      ) : null}
       {id ? (
         <AgentReadableDocumentDiscovery
           document={{ id }}
@@ -345,7 +361,9 @@ function PrivateDocumentNotice({
           accessState="authentication-required"
         />
       ) : null}
-      <section className="mx-auto flex min-h-screen max-w-md flex-col items-center justify-center px-6 text-center">
+      <section
+        className={`mx-auto flex min-h-screen max-w-md flex-col items-center justify-center px-6 text-center ${HIDDEN_WHILE_PRIVATE_LINK_REDIRECTS}`}
+      >
         <div className="mb-5 flex h-12 w-12 items-center justify-center rounded-xl border border-border bg-muted text-muted-foreground">
           <IconLock size={22} />
         </div>

package/corpus/templates/content/changelog/2026-10-02-a-page-link-you-cant-open-now-says-so-instead-of-opening-an.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-02
+---
+
+A page link you can't open now says so, with the account you're signed in as, instead of opening another page. People who can open a private share link no longer see "This document is private" first.

package/corpus/templates/content/changelog/2026-10-02-after-a-refresh-the-files-sidebar-shows-the-open-page-s-fold.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-10-02
+---
+
+After a refresh, the Files sidebar shows the open page's folders in one load instead of one level at a time