@backmatter/studio 0.0.15 → 0.0.16

package/src/pages/WorkspaceLayout.tsx

@@ -12,7 +12,10 @@ import { PageFrame } from "../ui/Page";
 import { Text } from "../ui/Text";
 import type { WorkspaceOutletContext } from "../workspace/types";
 import {
+  isWorkspaceContentIndexPath,
   isWorkspaceEditorPath,
+  isWorkspaceHomePath,
+  isWorkspaceCodePath,
   isWorkspaceMediaPath,
   isWorkspaceSettingsPath,
   isWorkspaceTypeIndexPath,
@@ -26,9 +29,12 @@ export function WorkspaceLayout() {
   const { workspaceSlug = "" } = useParams();
   const location = useLocation();
   const isEditor = isWorkspaceEditorPath(location.pathname);
+  const isContentIndex = isWorkspaceContentIndexPath(location.pathname);
   const isTypeIndex = isWorkspaceTypeIndexPath(location.pathname);
   const isSettings = isWorkspaceSettingsPath(location.pathname);
   const isMedia = isWorkspaceMediaPath(location.pathname);
+  const isCode = isWorkspaceCodePath(location.pathname);
+  const isHome = isWorkspaceHomePath(location.pathname);
   const { userId } = useAppChrome();
   const setNav = useSetWorkspaceNav();
   const replica = useReplicaState();
@@ -96,7 +102,10 @@ export function WorkspaceLayout() {
   }
 
   return (
-    <PageFrame flush={isEditor || isTypeIndex || isSettings || isMedia}>
+    <PageFrame
+      wide={isHome}
+      flush={isEditor || isContentIndex || isTypeIndex || isSettings || isMedia || isCode}
+    >
       <Outlet context={outletContext} />
     </PageFrame>
   );

package/src/pages/code-session-boot.ts

@@ -0,0 +1,43 @@
+// packages/studio/src/pages/code-session-boot.ts
+export type HostPhase = "stopped" | "installing" | "starting" | "ready" | "failed";
+
+export type BootStepState = "pending" | "active" | "done" | "failed";
+
+export type BootStep = { label: string; state: BootStepState };
+
+const LABELS = ["Start the container", "Install dependencies", "Start the dev server"] as const;
+
+/**
+ * The three steps a developer watches before the host shows. `furthest` is the
+ * latest phase seen, so a failure lands on the step that was running.
+ */
+export function bootSteps(input: {
+  opening: boolean;
+  phase: HostPhase | null;
+  furthest: "installing" | "starting" | null;
+}): BootStep[] {
+  const at = (index: number, state: BootStepState): BootStep[] =>
+    LABELS.map((label, i) => ({
+      label,
+      state: i < index ? "done" : i === index ? state : "pending",
+    }));
+
+  if (input.opening || input.phase === null) return at(0, "active");
+  if (input.phase === "installing") return at(1, "active");
+  if (input.phase === "starting") return at(2, "active");
+  if (input.phase === "ready") return LABELS.map((label) => ({ label, state: "done" }));
+  if (input.phase === "stopped") return at(0, "failed");
+  return at(input.furthest === "starting" ? 2 : input.furthest === "installing" ? 1 : 0, "failed");
+}
+
+/** Normalizes what someone types in the address bar to a path inside the host. */
+export function hostPath(input: string): string {
+  const trimmed = input.trim();
+  if (!trimmed) return "/";
+  try {
+    const url = new URL(trimmed);
+    return `${url.pathname}${url.search}${url.hash}` || "/";
+  } catch {
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  }
+}

package/src/pages/code-session-context.tsx

@@ -0,0 +1,51 @@
+// packages/studio/src/pages/code-session-context.ts
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useState,
+  type Dispatch,
+  type SetStateAction,
+} from "react";
+
+export type CodeSessionContextValue = {
+  sessionId: string;
+  editCount: number;
+  refresh: () => void;
+};
+
+const CodeSessionContext = createContext<CodeSessionContextValue | null>(null);
+const CodeSessionPublishContext = createContext<
+  Dispatch<SetStateAction<CodeSessionContextValue | null>> | null
+>(null);
+
+export function CodeSessionProvider({
+  children,
+  initial = null,
+}: {
+  children: React.ReactNode;
+  initial?: CodeSessionContextValue | null;
+}) {
+  const [published, setPublished] = useState<CodeSessionContextValue | null>(initial);
+  const value = useMemo(() => published, [published]);
+  return (
+    <CodeSessionContext.Provider value={value}>
+      <CodeSessionPublishContext.Provider value={setPublished}>
+        {children}
+      </CodeSessionPublishContext.Provider>
+    </CodeSessionContext.Provider>
+  );
+}
+
+export function useCodeSessionContext(): CodeSessionContextValue | null {
+  return useContext(CodeSessionContext);
+}
+
+export function usePublishCodeSession(): Dispatch<SetStateAction<CodeSessionContextValue | null>> {
+  const publish = useContext(CodeSessionPublishContext);
+  if (!publish) {
+    throw new Error("usePublishCodeSession requires CodeSessionProvider");
+  }
+  return publish;
+}

package/src/pages/code-session-files.ts

@@ -0,0 +1,42 @@
+// packages/studio/src/pages/code-session-files.ts
+export type FileNode =
+  | { kind: "file"; name: string; path: string }
+  | { kind: "dir"; name: string; path: string; children: FileNode[] };
+
+/** One checkout file as the session's container has it now. */
+export type WorkspaceFile =
+  | { path: string; content: string }
+  | { path: string; binary: true; size: number }
+  | { path: string; tooLarge: true; size: number };
+
+export function fileTree(paths: readonly string[]): FileNode[] {
+  const root: FileNode & { kind: "dir" } = { kind: "dir", name: "", path: "", children: [] };
+  for (const path of paths) {
+    const parts = path.split("/");
+    let dir = root;
+    parts.forEach((name, index) => {
+      const at = parts.slice(0, index + 1).join("/");
+      if (index === parts.length - 1) {
+        dir.children.push({ kind: "file", name, path: at });
+        return;
+      }
+      let next = dir.children.find(
+        (child): child is FileNode & { kind: "dir" } => child.kind === "dir" && child.name === name,
+      );
+      if (!next) {
+        next = { kind: "dir", name, path: at, children: [] };
+        dir.children.push(next);
+      }
+      dir = next;
+    });
+  }
+  return sortLevel(root.children);
+}
+
+function sortLevel(nodes: FileNode[]): FileNode[] {
+  return nodes
+    .map((node) => (node.kind === "dir" ? { ...node, children: sortLevel(node.children) } : node))
+    .sort((a, b) =>
+      a.kind !== b.kind ? (a.kind === "dir" ? -1 : 1) : a.name.localeCompare(b.name),
+    );
+}

package/src/pages/code-session-frame.ts

@@ -0,0 +1,52 @@
+// packages/studio/src/pages/code-session-frame.ts
+
+/** The host's own origin, and an entry URL carrying the ticket that admits this browser to it. */
+export type HostPreview = { origin: string; entry: string };
+
+/** The frame's address. The first load carries the ticket. A reload is that same path. */
+export function frameAddress(preview: HostPreview, path: string, reloads: number): string {
+  if (reloads === 0) return previewUrl(preview.entry, path);
+  return previewUrl(preview.origin, path);
+}
+
+export function previewUrl(base: string, path: string): string {
+  const from = new URL(base);
+  const url = new URL(path, from.origin);
+  from.searchParams.forEach((value, key) => url.searchParams.set(key, value));
+  return url.toString();
+}
+
+export type PathMemory = {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+};
+
+function pathKey(workspaceId: string): string {
+  return `backmatter:code-session-path:${workspaceId}`;
+}
+
+function isRoute(path: string | null): path is string {
+  return typeof path === "string" && path.startsWith("/") && !path.startsWith("//");
+}
+
+/** The route this workspace's preview was last on, kept across a reload of Studio. */
+export function rememberedPath(storage: PathMemory, workspaceId: string): string {
+  const raw = storage.getItem(pathKey(workspaceId));
+  return isRoute(raw) ? raw : "/";
+}
+
+export function rememberPath(storage: PathMemory, workspaceId: string, path: string): void {
+  if (!isRoute(path)) return;
+  storage.setItem(pathKey(workspaceId), path);
+}
+
+/** The route a framed host page reports through `postMessage`, if `message` is that report. */
+export function framedLocation(
+  message: { origin: string; data: unknown },
+  hostOrigin: string,
+): string | null {
+  if (message.origin !== new URL(hostOrigin).origin) return null;
+  const data = message.data as { type?: unknown; path?: unknown } | null;
+  if (data?.type !== "backmatter:preview-location" || typeof data.path !== "string") return null;
+  return data.path.startsWith("/") && !data.path.startsWith("//") ? data.path : null;
+}

package/src/pages/code-session-routes.ts

@@ -0,0 +1,42 @@
+// packages/studio/src/pages/code-session-routes.ts
+import {
+  isRoutable,
+  isTemplateSlug,
+  matchModelPath,
+  routeFor,
+  type RouteModel,
+} from "@backmatter/core";
+
+export type ContentRouteModel = RouteModel & {
+  path: string;
+  external?: boolean;
+  template?: string;
+};
+
+/** Public routes for the content files in a code session checkout. */
+export function contentRoutes(
+  models: readonly ContentRouteModel[],
+  files: readonly string[],
+): string[] {
+  const routes = new Set<string>();
+  for (const file of files) {
+    const repoPath = file.replace(/^\.\//, "").replace(/^\/+/, "");
+    for (const model of models) {
+      const hit = matchModelPath(model, repoPath);
+      if (!hit) continue;
+      if (isRoutable(model) && !isTemplateSlug(model, hit.slug)) {
+        const route = routeFor(model, hit.slug);
+        if (route) routes.add(route);
+      }
+      break;
+    }
+  }
+  return [...routes].sort((a, b) => (a === "/" ? -1 : b === "/" ? 1 : a.localeCompare(b)));
+}
+
+/** Routes whose path contains the address query. A blank query keeps the full list. */
+export function matchingRoutes(routes: readonly string[], query: string): string[] {
+  const needle = query.trim().toLowerCase();
+  if (!needle) return [...routes];
+  return routes.filter((route) => route.toLowerCase().includes(needle));
+}

package/src/pages/home-rows.ts

@@ -0,0 +1,140 @@
+// packages/studio/src/pages/home-rows.ts
+import type { ChangeStatus, RecentCommit } from "../api";
+import { routeFor } from "@backmatter/core";
+import { docTreeLabel } from "../chrome/content-repo-path";
+import type { ContentTypeNav } from "../chrome/content-type-groups";
+import { contentDocPath, settingsPath } from "../workspace-path";
+
+const STATUS_WORD: Record<ChangeStatus, string> = {
+  modified: "modified",
+  added: "new",
+  conflict: "conflict",
+  deleted: "deleted",
+};
+
+export type HomeChange = {
+  type: string;
+  slug: string;
+  status: ChangeStatus;
+  updatedAt?: string;
+};
+
+export type HomeModel = Pick<ContentTypeNav, "type" | "path"> & {
+  route?: string | false;
+  indexSlug?: string;
+};
+
+export type HomeRow = {
+  key: string;
+  label: string;
+  /** Public path when the model is routable. Null for data with no route. */
+  route: string | null;
+  status: string;
+  href: string | null;
+  updatedAt: string;
+};
+
+/** Public path for a changed document. Data models with `route: false` have none. */
+export function changedRoute(
+  change: Pick<HomeChange, "type" | "slug">,
+  model: Pick<HomeModel, "type" | "route" | "indexSlug"> | undefined,
+): string | null {
+  if (model?.route === false) return null;
+  const path = routeFor(
+    { type: change.type, route: model?.route, indexSlug: model?.indexSlug },
+    change.slug,
+  );
+  return path || null;
+}
+
+/** Working-tree rows for the workspace home, newest edit first. */
+export function homeRows(
+  changes: HomeChange[],
+  models: HomeModel[],
+  workspaceSlug: string,
+): HomeRow[] {
+  const rows = changes.map((change) => {
+    const model = models.find((item) => item.type === change.type);
+    const label = model ? docTreeLabel(model, change) : change.slug;
+    return {
+      key: `${change.type}/${change.slug}`,
+      label,
+      route: changedRoute(change, model),
+      status: STATUS_WORD[change.status],
+      href:
+        change.status === "deleted"
+          ? null
+          : contentDocPath(workspaceSlug, change.type, change.slug),
+      updatedAt: change.updatedAt ?? "",
+    };
+  });
+  rows.sort((a, b) => {
+    if (a.updatedAt !== b.updatedAt) return a.updatedAt < b.updatedAt ? 1 : -1;
+    return a.label.localeCompare(b.label);
+  });
+  return rows;
+}
+
+const RECENT_LIMIT = 4;
+
+export type HomeSummary = {
+  name: string;
+  branch: string;
+  defaultBranch: string;
+  uncommitted: number;
+  conflicts: number;
+  recent: HomeRow[];
+  modelCount: number;
+  repository: string | null;
+  siteUrl: string | null;
+  schemaHref: string;
+  githubHref: string;
+  generalHref: string;
+  /** Null until git status has loaded. Empty means the branch has no commits. */
+  commits: RecentCommit[] | null;
+};
+
+/** How long ago a commit landed, stable enough to test. */
+export function commitAge(iso: string, now: number): string {
+  const then = Date.parse(iso);
+  if (!Number.isFinite(then)) return "";
+  const minutes = Math.max(0, Math.round((now - then) / 60_000));
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.round(hours / 24);
+  if (days < 14) return `${days}d ago`;
+  return iso.slice(0, 10);
+}
+
+/** The few facts the workspace home can show without inventing activity. */
+export function homeSummary(input: {
+  name: string;
+  slug: string;
+  branch: string;
+  defaultBranch: string;
+  repository: string | null;
+  siteUrl: string | null;
+  modelCount: number;
+  changes: HomeChange[];
+  models: HomeModel[];
+  commits?: RecentCommit[] | null;
+}): HomeSummary {
+  const rows = homeRows(input.changes, input.models, input.slug);
+  return {
+    name: input.name,
+    branch: input.branch,
+    defaultBranch: input.defaultBranch,
+    uncommitted: rows.length,
+    conflicts: input.changes.filter((change) => change.status === "conflict").length,
+    recent: rows.slice(0, RECENT_LIMIT),
+    modelCount: input.modelCount,
+    repository: input.repository,
+    siteUrl: input.siteUrl,
+    schemaHref: settingsPath(input.slug, "schema"),
+    githubHref: settingsPath(input.slug, "github"),
+    generalHref: settingsPath(input.slug, "general"),
+    commits: input.commits ?? null,
+  };
+}

package/src/pages/preview-size.ts

@@ -0,0 +1,33 @@
+// packages/studio/src/pages/preview-size.ts
+export type PreviewSize = "desktop" | "tablet" | "phone";
+
+export const PREVIEW_SIZE_KEY = "backmatter-preview-size";
+
+export type PreviewSizeStore = {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+};
+
+export function previewFrameWidth(size: PreviewSize): "390px" | "768px" | null {
+  if (size === "phone") return "390px";
+  if (size === "tablet") return "768px";
+  return null;
+}
+
+export function readPreviewSize(store?: PreviewSizeStore): PreviewSize {
+  try {
+    const raw = (store ?? localStorage).getItem(PREVIEW_SIZE_KEY);
+    if (raw === "desktop" || raw === "tablet" || raw === "phone") return raw;
+  } catch {
+    // Private mode, or no browser storage.
+  }
+  return "desktop";
+}
+
+export function persistPreviewSize(size: PreviewSize, store?: PreviewSizeStore) {
+  try {
+    (store ?? localStorage).setItem(PREVIEW_SIZE_KEY, size);
+  } catch {
+    // Ignore quota and private mode.
+  }
+}

package/src/pages/session-preview.ts

@@ -0,0 +1,109 @@
+// packages/studio/src/pages/session-preview.ts
+// Studio side of pointing at the running host. Same preview channel as the
+// document editor. The session never pushes a document into the page.
+import { matchRoute, type RouteModel } from "@backmatter/core";
+import {
+  createPreviewEditor,
+  type PreviewChannelRef,
+  type PreviewEditorSession,
+  type PreviewTransport,
+} from "@backmatter/core/preview";
+import type { ChatPointer } from "../chat/chat-context";
+
+/** The document a hello or grab refers to. A route ref is resolved against the models. */
+export function sessionDocument(
+  ref: PreviewChannelRef,
+  models: readonly RouteModel[],
+): { type: string; slug: string } | null {
+  if (ref.type === "route") {
+    const path = ref.slug.split(/[?#]/, 1)[0] || "/";
+    const hit = matchRoute(models, path);
+    return hit ? { type: hit.type, slug: hit.slug } : null;
+  }
+  if (!ref.type || !ref.slug) return null;
+  return { type: ref.type, slug: ref.slug };
+}
+
+export type SessionPreviewBinding = {
+  arm(on: boolean): void;
+  highlight(blockId: string | null): void;
+  /** Ask a page that already loaded to send hello again. */
+  nudge(): void;
+  close(): void;
+};
+
+export function bindSessionPreview(options: {
+  transport: PreviewTransport;
+  onCanPoint(on: boolean): void;
+  onPointer(pointer: ChatPointer): void;
+  onDisarm(): void;
+  /** The document a hello or grab refers to. A route ref is resolved by the caller. */
+  documentAt(ref: PreviewChannelRef): { type: string; slug: string } | null;
+}): SessionPreviewBinding {
+  let ref: PreviewChannelRef = { type: "_", slug: "_" };
+  let known = false;
+  let wantPoint = false;
+  let editor: PreviewEditorSession | null = null;
+
+  function remember(next: PreviewChannelRef) {
+    ref = {
+      type: next.type,
+      slug: next.slug,
+      ...(next.branch ? { branch: next.branch } : {}),
+      ...(next.tree ? { tree: next.tree } : {}),
+    };
+    known = true;
+  }
+
+  editor = createPreviewEditor({
+    transport: options.transport,
+    ref: () => ref,
+    onHello(next, capabilities) {
+      remember(next);
+      options.onCanPoint(capabilities?.includes("point") ?? false);
+      editor?.point(wantPoint);
+    },
+    onGrab(grab) {
+      const doc = options.documentAt(grab.ref);
+      if (!doc) return;
+      options.onPointer({
+        type: doc.type,
+        slug: doc.slug,
+        blockId: grab.blockId,
+        blockType: grab.blockType,
+        blockIndex: grab.blockIndex,
+        quote: grab.quote,
+        ...(grab.component ? { component: grab.component } : {}),
+        ...(grab.file ? { file: grab.file } : {}),
+        ...(grab.line ? { line: grab.line } : {}),
+        ...(grab.column ? { column: grab.column } : {}),
+        ...(grab.stack ? { stack: grab.stack } : {}),
+      });
+    },
+    onPoint(on) {
+      if (!on) {
+        wantPoint = false;
+        options.onDisarm();
+      }
+    },
+  });
+
+  options.onCanPoint(false);
+
+  return {
+    arm(on) {
+      wantPoint = on;
+      if (known) editor?.point(on);
+    },
+    highlight(blockId) {
+      if (known) editor?.highlight(blockId);
+    },
+    nudge() {
+      if (!known) editor?.point(false);
+    },
+    close() {
+      editor?.close();
+      editor = null;
+    },
+  };
+}

package/src/pages/use-session-preview.ts

@@ -0,0 +1,70 @@
+// packages/studio/src/pages/use-session-preview.ts
+import { useEffect, useRef } from "react";
+import type { RouteModel } from "@backmatter/core";
+import { POINTER_ARM_EVENT } from "../chat/pointer-arm";
+import { useChatUIOptional } from "../chat/ChatProvider";
+import { registerPreviewHighlight } from "../preview-highlight";
+import { previewFrameTransport } from "./preview-bridge";
+import { bindSessionPreview, sessionDocument } from "./session-preview";
+
+/** Point at a block in the code session's host, the same way the document editor does. */
+export function useSessionPreview(input: {
+  frame: HTMLIFrameElement | null;
+  origin: string | null;
+  models: readonly RouteModel[];
+  enabled: boolean;
+}): void {
+  const ui = useChatUIOptional();
+  const uiRef = useRef(ui);
+  uiRef.current = ui;
+  const modelsRef = useRef(input.models);
+  modelsRef.current = input.models;
+  const armRef = useRef<(on: boolean) => void>(() => {});
+  const highlightRef = useRef<(blockId: string | null) => void>(() => {});
+
+  useEffect(() => {
+    if (!input.enabled) return;
+    const stop = registerPreviewHighlight((blockId) => highlightRef.current(blockId));
+    function onArm(event: Event) {
+      const on = (event as CustomEvent<{ on?: boolean }>).detail?.on === true;
+      armRef.current(on);
+    }
+    window.addEventListener(POINTER_ARM_EVENT, onArm);
+    return () => {
+      window.removeEventListener(POINTER_ARM_EVENT, onArm);
+      stop();
+      uiRef.current?.setPointerHighlight("local");
+      uiRef.current?.setPreviewPointer(false);
+    };
+  }, [input.enabled]);
+
+  useEffect(() => {
+    const chat = uiRef.current;
+    const frame = input.frame;
+    const origin = input.origin;
+    if (!input.enabled || !chat?.codeSessionId || !frame || !origin) return;
+    const transport = previewFrameTransport({ frame, siteOrigin: origin });
+    if (!transport) return;
+    chat.setPointerHighlight("channel");
+    const binding = bindSessionPreview({
+      transport,
+      onCanPoint: (on) => uiRef.current?.setPreviewPointer(on),
+      onPointer: (pointer) => uiRef.current?.addPointer(pointer),
+      onDisarm: () => {
+        window.dispatchEvent(new CustomEvent(POINTER_ARM_EVENT, { detail: { on: false } }));
+      },
+      documentAt: (ref) => sessionDocument(ref, modelsRef.current),
+    });
+    armRef.current = (on) => binding.arm(on);
+    highlightRef.current = (blockId) => binding.highlight(blockId);
+    binding.nudge();
+    return () => {
+      armRef.current = () => {};
+      highlightRef.current = () => {};
+      binding.close();
+      transport.close();
+      window.dispatchEvent(new CustomEvent(POINTER_ARM_EVENT, { detail: { on: false } }));
+      uiRef.current?.setPreviewPointer(false);
+    };
+  }, [input.enabled, input.frame, input.origin]);
+}

package/src/replica/store.ts

@@ -165,6 +165,8 @@ export function createReplicaStore(
           cached.head ??
           (slot?.headSha ? { sha: slot.headSha, updatedAt: "" } : null),
         changes: changesFromDocs(slot?.docs ?? []),
+        fetchedChanges: entry.git?.fetched,
+        recentCommits: entry.git?.recentCommits,
       };
     },
   };
@@ -241,6 +243,7 @@ export function createReplicaStore(
       const existing = checkouts[snapshot.workspace.id];
       const defaultBranch =
         snapshot.workspace.githubDefaultBranch ?? snapshot.checkout.branch;
+      const sameBranch = existing?.currentBranch === snapshot.checkout.branch;
       checkouts = {
         ...checkouts,
         [snapshot.workspace.id]: {
@@ -257,6 +260,12 @@ export function createReplicaStore(
                       : "",
                 }
               : null,
+            ...(sameBranch && existing?.git?.fetched
+              ? { fetched: existing.git.fetched }
+              : {}),
+            ...(sameBranch && existing?.git?.recentCommits
+              ? { recentCommits: existing.git.recentCommits }
+              : {}),
           },
           branches: {
             ...(existing?.branches ?? {}),
@@ -400,6 +409,8 @@ export function createReplicaStore(
             defaultBranch: git.defaultBranch,
             branches: git.branches,
             head: git.head,
+            fetched: git.changes,
+            recentCommits: git.recentCommits,
           },
         },
       };

package/src/replica/types.ts

@@ -2,7 +2,9 @@
 import type {
   DocListItem,
   DocStatus,
+  GitChange,
   GitState,
+  RecentCommit,
   SchemaPayload,
   WorkspaceDetail,
   WorkspaceSummary,
@@ -61,6 +63,10 @@ export type ReplicaGitCache = {
   defaultBranch: string;
   branches: Array<{ name: string }>;
   head: { sha: string; updatedAt: string } | null;
+  /** Git status changes for the current branch, once fetched. */
+  fetched?: GitChange[];
+  /** Latest commits on this branch, once git status has been fetched. */
+  recentCommits?: RecentCommit[];
 };
 
 export type ReplicaCheckout = {