@pantheon-systems/create-p1-starter-kit 0.10.0 → 0.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pantheon-systems/create-p1-starter-kit",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Scaffold a new P1 starter project",
   "type": "module",
   "bin": {
@@ -38,15 +38,15 @@
     "isomorphic-dompurify": "^3.18.0",
     "react": "^19.2.5",
     "vitest": "^4.1.5",
-    "@pantheon-systems/css-client": "0.10.0",
+    "@pantheon-systems/css-client": "0.11.1",
     "@pantheon-systems/eslint-config": "0.1.0",
-    "@pantheon-systems/puck-css": "0.10.0"
+    "@pantheon-systems/puck-css": "0.11.1"
   },
   "dependencies": {
     "@clack/prompts": "^1.5.1",
     "picocolors": "^1.1.1"
   },
-  "license": "MIT",
+  "license": "UNLICENSED",
   "homepage": "https://github.com/pantheon-systems/p1-platform/tree/main/packages/create-p1-starter-kit",
   "scripts": {
     "build": "node scripts/build-template.js",

package/template/__tests__/image-block.test.tsx

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { isValidElement, type ReactNode } from "react";
+
+const SRC = "https://example.com/photo.jpg";
+
+// react-dom is not available where the scaffolded template runs its tests, so
+// inspect the element tree the block returns rather than rendering it.
+function findImg(node: ReactNode): Record<string, unknown> | null {
+  if (node == null || typeof node !== "object") return null;
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      const found = findImg(child);
+      if (found) return found;
+    }
+    return null;
+  }
+  if (!isValidElement(node)) return null;
+  const props = (node.props ?? {}) as Record<string, unknown>;
+  if (node.type === "img") return props;
+  return findImg(props.children as ReactNode);
+}
+
+describe("imageBlock", () => {
+  it("exposes a loading field defaulting to lazy", async () => {
+    const { imageBlock } = await import("../components/puck/image-block");
+    expect(imageBlock.fields.loading.type).toBe("radio");
+    expect(imageBlock.fields.loading.options.map((o) => o.value)).toEqual([
+      "lazy",
+      "eager",
+    ]);
+    expect(imageBlock.defaultProps.loading).toBe("lazy");
+  });
+
+  it("lazy-loads even when the prop is missing (documents saved before the field existed)", async () => {
+    const { imageBlock } = await import("../components/puck/image-block");
+    const img = findImg(imageBlock.render({ src: SRC, alt: "A photo" }));
+    expect(img?.loading).toBe("lazy");
+    expect(img?.decoding).toBe("async");
+  });
+
+  it("renders eager when the editor chooses it", async () => {
+    const { imageBlock } = await import("../components/puck/image-block");
+    const img = findImg(
+      imageBlock.render({ src: SRC, alt: "A photo", loading: "eager" }),
+    );
+    expect(img?.loading).toBe("eager");
+  });
+});

package/template/__tests__/page-seo-meta-templates.test.ts

@@ -4,8 +4,11 @@ vi.mock("../lib/remote-datasource-fetchers", () => ({
   REMOTE_DATASOURCE_FETCHERS: {},
 }));
 
+vi.mock("@pantheon-systems/p1-next-sdk/server", () => ({
+  loadRouteTemplateKeys: vi.fn().mockResolvedValue([]),
+}));
+
 vi.mock("@pantheon-systems/puck-css/server", () => ({
-  listRouteTemplateKeysFromDatabase: vi.fn().mockResolvedValue([]),
   extractReferencedDatasourceIds: vi.fn().mockReturnValue([]),
   loadRemoteDatasourceContext: vi.fn().mockResolvedValue({}),
   resolveStringTemplates: vi.fn(async (input: string) =>
@@ -40,7 +43,6 @@ const resolve = (props: Record<string, unknown>) =>
   resolvePageMetadata({
     pageData: pageWithRootProps(props),
     path: "/q3",
-    searchParams: {},
   });
 
 const og = (m: Awaited<ReturnType<typeof resolvePageMetadata>>) =>

package/template/__tests__/page-seo-meta.test.ts

@@ -4,8 +4,11 @@ vi.mock("../lib/remote-datasource-fetchers", () => ({
   REMOTE_DATASOURCE_FETCHERS: {},
 }));
 
+vi.mock("@pantheon-systems/p1-next-sdk/server", () => ({
+  loadRouteTemplateKeys: vi.fn().mockResolvedValue([]),
+}));
+
 vi.mock("@pantheon-systems/puck-css/server", () => ({
-  listRouteTemplateKeysFromDatabase: vi.fn().mockResolvedValue([]),
   extractReferencedDatasourceIds: vi.fn().mockReturnValue([]),
   loadRemoteDatasourceContext: vi.fn().mockResolvedValue({}),
   resolveStringTemplates: vi.fn(async (input: string) =>
@@ -46,7 +49,6 @@ describe("resolvePageMetadata — _meta", () => {
         },
       }),
       path: "/q3",
-      searchParams: {},
     });
 
     expect(og(meta).title).toBe("The launch, in numbers");
@@ -63,7 +65,6 @@ describe("resolvePageMetadata — _meta", () => {
         description: "How the launch went.",
       }),
       path: "/q3",
-      searchParams: {},
     });
 
     expect(og(meta).title).toBe("Q3 Launch Recap");
@@ -78,7 +79,6 @@ describe("resolvePageMetadata — _meta", () => {
         _meta: { ogDescription: "Static description." },
       }),
       path: "/greet",
-      searchParams: {},
     });
 
     expect(meta.title).toBe("Hello World");
@@ -89,7 +89,6 @@ describe("resolvePageMetadata — _meta", () => {
     const meta = await resolvePageMetadata({
       pageData: pageWithRootProps({ title: "My Puck Editor" }),
       path: "/new",
-      searchParams: {},
     });
 
     expect(meta.title).toBeUndefined();

package/template/__tests__/page-seo.test.ts

@@ -6,8 +6,11 @@ vi.mock("../lib/remote-datasource-fetchers", () => ({
   REMOTE_DATASOURCE_FETCHERS: {},
 }));
 
+vi.mock("@pantheon-systems/p1-next-sdk/server", () => ({
+  loadRouteTemplateKeys: vi.fn().mockResolvedValue([]),
+}));
+
 vi.mock("@pantheon-systems/puck-css/server", () => ({
-  listRouteTemplateKeysFromDatabase: vi.fn().mockResolvedValue([]),
   extractReferencedDatasourceIds: vi.fn().mockReturnValue([]),
   loadRemoteDatasourceContext: vi.fn().mockResolvedValue({}),
   resolveStringTemplates: vi.fn(async (input: string) =>
@@ -36,7 +39,6 @@ describe("resolvePageMetadata", () => {
         _seo: { siteName: "Acme Docs" },
       }),
       path: "/about/team",
-      searchParams: {},
     });
 
     expect(meta.title).toBe("About Our Team");
@@ -62,7 +64,6 @@ describe("resolvePageMetadata", () => {
         _seo: { siteName: "Acme Docs" },
       }),
       path: "/untitled",
-      searchParams: {},
     });
 
     expect(meta.title).toBeUndefined();
@@ -81,7 +82,6 @@ describe("resolvePageMetadata", () => {
         description: "Welcome, {{name}}!",
       }),
       path: "/greet",
-      searchParams: {},
     });
 
     expect(meta.title).toBe("Hello World");
@@ -103,7 +103,6 @@ describe("resolvePageMetadata", () => {
         },
       }),
       path: "/untitled",
-      searchParams: {},
     });
 
     expect(meta.title).toBe("Root Title");
@@ -116,7 +115,6 @@ describe("resolvePageMetadata", () => {
     const meta = await resolvePageMetadata({
       pageData: null,
       path: "/",
-      searchParams: {},
     });
 
     expect(meta.title).toBeUndefined();

package/template/__tests__/published-page-404.test.ts

@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { loadPublishedPage, notFound } = vi.hoisted(() => ({
+  loadPublishedPage: vi.fn(),
+  notFound: vi.fn(() => {
+    throw new Error("NEXT_NOT_FOUND");
+  }),
+}));
+
+vi.mock("@pantheon-systems/p1-next-sdk/server", () => ({
+  loadPublishedPage,
+  loadRouteTemplateKeys: vi.fn().mockResolvedValue([]),
+  createCssQueryFetchers: vi.fn().mockReturnValue([]),
+}));
+
+vi.mock("next/navigation", () => ({ notFound }));
+
+vi.mock("@pantheon-systems/puck-css/server", () => ({
+  pagePathFromCatchAllSegments: (segments: string[]) => `/${segments.join("/")}`,
+  loadRemoteDatasourceContext: vi.fn().mockResolvedValue({}),
+  extractReferencedDatasourceIds: vi.fn().mockReturnValue([]),
+  resolveDataTemplates: vi.fn(async (d: unknown) => d),
+}));
+
+vi.mock("../lib/remote-datasource-fetchers", () => ({
+  REMOTE_DATASOURCE_FETCHERS: [],
+}));
+
+vi.mock("../app/[...puckPath]/client", () => ({ Client: () => null }));
+vi.mock("../components/content-unavailable", () => ({
+  ContentUnavailable: () => null,
+}));
+
+import Page from "../app/[...puckPath]/page";
+
+const render = (...segments: string[]) =>
+  Page({ params: Promise.resolve({ puckPath: segments }) });
+
+describe("catch-all route — missing vs unavailable", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  // The route is statically renderable, so a 200 here would write every junk URL
+  // a crawler probes into the response cache as a successful page.
+  it("404s a path with no published page", async () => {
+    loadPublishedPage.mockResolvedValue({ status: "missing" });
+    await expect(render("nope")).rejects.toThrow("NEXT_NOT_FOUND");
+    expect(notFound).toHaveBeenCalled();
+  });
+
+  // 404ing here would deindex a live page over a transient backend blip.
+  it("does not 404 when the backend is unreachable", async () => {
+    loadPublishedPage.mockResolvedValue({ status: "unavailable" });
+    await render("real-page");
+    expect(notFound).not.toHaveBeenCalled();
+  });
+
+  it("renders published content", async () => {
+    loadPublishedPage.mockResolvedValue({
+      status: "ok",
+      data: { root: { props: { title: "Hi" } }, content: [] },
+    });
+    await render("blog");
+    expect(notFound).not.toHaveBeenCalled();
+  });
+});

package/template/app/[...puckPath]/page.tsx

@@ -4,17 +4,20 @@
 
 import { cache } from "react";
 import type { Metadata } from "next";
+import { notFound } from "next/navigation";
 import {
   loadRemoteDatasourceContext,
   extractReferencedDatasourceIds,
-  getPage,
-  listRouteTemplateKeysFromDatabase,
   resolveDataTemplates,
-  ensureInitialized,
   pagePathFromCatchAllSegments,
 } from "@pantheon-systems/puck-css/server";
-import { createCssQueryFetchers } from "@pantheon-systems/p1-next-sdk/server";
+import {
+  createCssQueryFetchers,
+  loadPublishedPage,
+  loadRouteTemplateKeys,
+} from "@pantheon-systems/p1-next-sdk/server";
 import { REMOTE_DATASOURCE_FETCHERS } from "../../lib/remote-datasource-fetchers";
+import { ContentUnavailable } from "../../components/content-unavailable";
 import { resolvePageMetadata } from "../../lib/page-seo";
 import { Client } from "./client";
 
@@ -33,23 +36,30 @@ function isInternalPath(path: string): boolean {
   );
 }
 
-const initPromise = ensureInitialized({
-  p1BaseUrl: process.env.NEXT_PUBLIC_CSS_BASE_URL,
-  p1ApiKey: process.env.CSS_API_KEY,
-  p1SiteId: process.env.NEXT_PUBLIC_CSS_SITE_ID,
-  // Default to "main" when unset: server components (no user token) need a
-  // branch to list/read documents (e.g. the /structure routes table).
-  p1BranchId: process.env.NEXT_PUBLIC_CSS_BRANCH_ID ?? "main",
-});
+/**
+ * Backstop only: publishing calls revalidatePath for the affected routes, so
+ * cached pages normally refresh the moment their content changes. This bounds
+ * how long an edit made outside that path (a direct API write, a restored
+ * branch) can stay stale.
+ */
+export const revalidate = 300;
+
+/**
+ * Empty on purpose. Routes are authored in P1, so there is nothing to enumerate
+ * at build time — but declaring this is what marks the segment statically
+ * renderable at all; without it every path here renders fully dynamically and
+ * no response is ever cacheable. Unlisted paths render on first request and are
+ * cached from then on (dynamicParams defaults to true).
+ */
+export function generateStaticParams(): { puckPath: string[] }[] {
+  return [];
+}
 
 export async function generateMetadata({
   params,
-  searchParams,
 }: {
   params: Promise<{ puckPath: string[] }>;
-  searchParams: Promise<Record<string, string | string[] | undefined>>;
 }): Promise<Metadata> {
-  await initPromise;
   const { puckPath = [] } = await params;
   const path = pagePathFromCatchAllSegments(puckPath);
 
@@ -57,78 +67,52 @@ export async function generateMetadata({
     return { title: "Not Found" };
   }
 
-  const [pageData, sp] = await Promise.all([getPage(path), searchParams]);
-  return resolvePageMetadata({ pageData, path, searchParams: sp });
+  const result = await loadPublishedPage(path);
+  if (result.status === "missing") return { title: "Not Found" };
+  if (result.status === "unavailable") {
+    return { title: "Temporarily unavailable" };
+  }
+  return resolvePageMetadata({ pageData: result.data, path });
 }
 
 export default async function Page({
   params,
-  searchParams,
 }: {
   params: Promise<{ puckPath: string[] }>;
-  searchParams: Promise<Record<string, string | string[] | undefined>>;
 }) {
-  await initPromise;
   const { puckPath = [] } = await params;
   const path = pagePathFromCatchAllSegments(puckPath);
 
   if (isInternalPath(path)) {
-    const { notFound } = await import("next/navigation");
     notFound();
   }
 
-  const [data, searchParamData, routeTemplateKeys, cssQueryFetchers] = await Promise.all([
-    getPage(path),
-    searchParams,
-    listRouteTemplateKeysFromDatabase(),
-    getCssQueryFetchers(),
-  ]);
+  const result = await loadPublishedPage(path);
 
-  if (!data) {
-    return (
-      <main className="flex min-h-screen items-center justify-center bg-gray-50">
-        <div className="mx-auto max-w-lg px-6 py-16 text-center">
-          <h1 className="text-3xl font-bold tracking-tight text-gray-900">
-            404 &ndash; This page doesn&apos;t exist yet
-          </h1>
-          <p className="mt-4 text-gray-600">
-            This page hasn&apos;t been created. Use the editor to build it.
-          </p>
-
-          <nav className="mt-10 flex flex-col gap-3">
-            <a
-              href={`/p1${path}`}
-              className="rounded-lg bg-gray-900 px-5 py-3 text-sm font-medium text-white hover:bg-gray-700"
-            >
-              Edit this page
-            </a>
-            <a
-              href="/p1"
-              className="rounded-lg border border-gray-300 px-5 py-3 text-sm font-medium text-gray-900 hover:bg-gray-100"
-            >
-              Open the Page Editor
-            </a>
-            <a
-              href={`${process.env.NEXT_PUBLIC_P1_ADMIN_DASHBOARD_URL || "https://content.pantheon.io"}/dashboard/sites`}
-              target="_blank"
-              rel="noopener noreferrer"
-              className="rounded-lg border border-gray-300 px-5 py-3 text-sm font-medium text-gray-900 hover:bg-gray-100"
-            >
-              P1 Dashboard &rarr;
-            </a>
-          </nav>
-        </div>
-      </main>
-    );
+  // A real 404, so misses are not cached as successes now that this route is
+  // statically renderable. An outage is deliberately not a 404 — that would
+  // deindex published pages over a transient blip.
+  if (result.status === "missing") {
+    notFound();
   }
+  if (result.status === "unavailable") {
+    return <ContentUnavailable />;
+  }
+
+  const data = result.data;
+
+  const [routeTemplateKeys, cssQueryFetchers] = await Promise.all([
+    loadRouteTemplateKeys(),
+    getCssQueryFetchers(),
+  ]);
+  const builtinFetchers = [...REMOTE_DATASOURCE_FETCHERS, ...cssQueryFetchers];
 
   const referencedDatasourceIds = extractReferencedDatasourceIds(data);
   const context = await loadRemoteDatasourceContext({
-    searchParams: searchParamData,
     fetchImpl: fetch,
     pagePath: path,
     routeTemplateKeys,
-    builtinFetchers: [...REMOTE_DATASOURCE_FETCHERS, ...cssQueryFetchers],
+    builtinFetchers,
     referencedDatasourceIds,
   });
   const resolvedData = await resolveDataTemplates(data, context);
@@ -144,5 +128,3 @@ export default async function Page({
     />
   );
 }
-
-export const dynamic = "force-dynamic";

package/template/app/not-found.tsx

@@ -0,0 +1,11 @@
+/**
+ * Rendered by notFound() when a path has no published page. Being a real 404
+ * rather than a 200 is what keeps crawler traffic from filling the response
+ * cache with "doesn't exist yet" pages and getting them indexed.
+ */
+
+import { PageMissing } from "../components/page-missing";
+
+export default function NotFound() {
+  return <PageMissing />;
+}

package/template/app/page.tsx

@@ -1,44 +1,44 @@
 import {
-  ensureInitialized,
-  getPage,
-  listRouteTemplateKeysFromDatabase,
   resolveDataTemplates,
   extractReferencedDatasourceIds,
   loadRemoteDatasourceContext,
 } from "@pantheon-systems/puck-css/server";
+import {
+  loadPublishedPage,
+  loadRouteTemplateKeys,
+} from "@pantheon-systems/p1-next-sdk/server";
 import type { Metadata } from "next";
 import { WelcomeBlockRender } from "../components/puck/welcome-block-render";
 import { resolvePageMetadata } from "../lib/page-seo";
 import { REMOTE_DATASOURCE_FETCHERS } from "../lib/remote-datasource-fetchers";
 import { Client } from "./[...puckPath]/client";
 
-const initPromise = ensureInitialized({
-  p1BaseUrl: process.env.NEXT_PUBLIC_CSS_BASE_URL,
-  p1ApiKey: process.env.CSS_API_KEY,
-  p1SiteId: process.env.NEXT_PUBLIC_CSS_SITE_ID,
-  // Default to "main" when unset: server components (no user token) need a
-  // branch to list/read documents (e.g. the /structure routes table).
-  p1BranchId: process.env.NEXT_PUBLIC_CSS_BRANCH_ID ?? "main",
-});
+/**
+ * Backstop only: publishing calls revalidatePath("/"), so the home page
+ * normally refreshes the moment its content changes. This bounds how long an
+ * edit made outside that path can stay stale.
+ */
+export const revalidate = 300;
 
 export async function generateMetadata(): Promise<Metadata> {
-  await initPromise;
-  const pageData = await getPage("/");
-  if (!pageData) {
+  const result = await loadPublishedPage("/");
+  if (result.status !== "ok") {
     return { title: "P1 Starter Kit" };
   }
-  return resolvePageMetadata({ pageData, path: "/", searchParams: {} });
+  return resolvePageMetadata({ pageData: result.data, path: "/" });
 }
 
 export default async function HomePage() {
-  await initPromise;
-  const data = await getPage("/");
+  const result = await loadPublishedPage("/");
 
-  if (data) {
-    const routeTemplateKeys = await listRouteTemplateKeysFromDatabase();
+  // Unlike the catch-all, "/" never 404s: it is a single fixed URL rather than
+  // an unbounded crawler surface, and the welcome block is the correct state for
+  // a freshly scaffolded site — including one with no backend configured yet.
+  if (result.status === "ok") {
+    const data = result.data;
+    const routeTemplateKeys = await loadRouteTemplateKeys();
     const referencedDatasourceIds = extractReferencedDatasourceIds(data);
     const context = await loadRemoteDatasourceContext({
-      searchParams: {},
       fetchImpl: fetch,
       pagePath: "/",
       routeTemplateKeys,
@@ -75,5 +75,3 @@ export default async function HomePage() {
     />
   );
 }
-
-export const dynamic = "force-dynamic";

package/template/components/content-unavailable.tsx

@@ -0,0 +1,22 @@
+/**
+ * Shown when the content backend could not be reached, as distinct from a path
+ * with no page. A published page must not 404 because of a backend blip — that
+ * would deindex live content — so this renders a 200 holding page instead, on a
+ * render the SDK has already made uncacheable via connection().
+ */
+
+export function ContentUnavailable() {
+  return (
+    <main className="flex min-h-screen items-center justify-center bg-gray-50">
+      <div className="mx-auto max-w-lg px-6 py-16 text-center">
+        <h1 className="text-3xl font-bold tracking-tight text-gray-900">
+          This page is temporarily unavailable
+        </h1>
+        <p className="mt-4 text-gray-600">
+          We couldn&apos;t load this content just now. Please try again in a
+          moment.
+        </p>
+      </div>
+    </main>
+  );
+}

package/template/components/page-missing.tsx

@@ -0,0 +1,49 @@
+"use client";
+
+/**
+ * Shown for a path with no published page. Client-side because it renders from
+ * the not-found boundary, which receives no params — usePathname is the only
+ * way to point "Edit this page" at the path the visitor actually asked for.
+ */
+
+import { usePathname } from "next/navigation";
+
+export function PageMissing() {
+  const pathname = usePathname() || "/";
+
+  return (
+    <main className="flex min-h-screen items-center justify-center bg-gray-50">
+      <div className="mx-auto max-w-lg px-6 py-16 text-center">
+        <h1 className="text-3xl font-bold tracking-tight text-gray-900">
+          404 &ndash; This page doesn&apos;t exist yet
+        </h1>
+        <p className="mt-4 text-gray-600">
+          This page hasn&apos;t been created. Use the editor to build it.
+        </p>
+
+        <nav className="mt-10 flex flex-col gap-3">
+          <a
+            href={`/p1${pathname}`}
+            className="rounded-lg bg-gray-900 px-5 py-3 text-sm font-medium text-white hover:bg-gray-700"
+          >
+            Edit this page
+          </a>
+          <a
+            href="/p1"
+            className="rounded-lg border border-gray-300 px-5 py-3 text-sm font-medium text-gray-900 hover:bg-gray-100"
+          >
+            Open the Page Editor
+          </a>
+          <a
+            href={`${process.env.NEXT_PUBLIC_P1_ADMIN_DASHBOARD_URL || "https://content.pantheon.io"}/dashboard/sites`}
+            target="_blank"
+            rel="noopener noreferrer"
+            className="rounded-lg border border-gray-300 px-5 py-3 text-sm font-medium text-gray-900 hover:bg-gray-100"
+          >
+            P1 Dashboard &rarr;
+          </a>
+        </nav>
+      </div>
+    </main>
+  );
+}

package/template/components/puck/image-block.tsx

@@ -6,18 +6,39 @@ export const imageBlock = {
     src: { type: "text" as const, label: "Image URL" },
     alt: { type: "text" as const, label: "Alt text" },
     caption: { type: "textarea" as const, label: "Caption (optional)" },
+    loading: {
+      type: "radio" as const,
+      label: "Loading",
+      options: [
+        { label: "Lazy", value: "lazy" },
+        { label: "Eager", value: "eager" },
+      ],
+    },
   },
   defaultProps: {
     src: "https://images.unsplash.com/photo-1506905925346-21bda4d32df4?w=1200&q=80",
     alt: "Mountain landscape",
     caption: "",
+    loading: "lazy",
   },
-  render: ({ src, alt, caption }: { src?: string; alt?: string; caption?: string }) => (
+  render: ({
+    src,
+    alt,
+    caption,
+    loading,
+  }: {
+    src?: string;
+    alt?: string;
+    caption?: string;
+    loading?: "lazy" | "eager";
+  }) => (
     <figure className={`m-0 ${blockPaddingClass}`}>
       {src ? (
         <img
           src={src}
           alt={alt || ""}
+          loading={loading === "eager" ? "eager" : "lazy"}
+          decoding="async"
           className="block h-auto max-h-[400px] w-full max-w-4xl rounded-lg object-contain"
         />
       ) : (

package/template/lib/page-seo.ts

@@ -6,9 +6,9 @@ import type {
 import {
   loadRemoteDatasourceContext,
   extractReferencedDatasourceIds,
-  listRouteTemplateKeysFromDatabase,
   resolveStringTemplates,
 } from "@pantheon-systems/puck-css/server";
+import { loadRouteTemplateKeys } from "@pantheon-systems/p1-next-sdk/server";
 import { REMOTE_DATASOURCE_FETCHERS } from "./remote-datasource-fetchers";
 import { buildPageMetadata } from "./seo-metadata";
 import type { PageMetaFields } from "./seo-metadata";
@@ -43,11 +43,9 @@ const carriesTemplate = (value: unknown): value is string =>
 export async function resolvePageMetadata({
   pageData,
   path,
-  searchParams,
 }: {
   pageData: PageData;
   path: string;
-  searchParams: Record<string, string | string[] | undefined>;
 }): Promise<Metadata> {
   const rootProps: Record<string, unknown> | undefined = pageData?.root.props;
   const seo: Partial<SeoMetadata> | undefined = rootProps?._seo;
@@ -67,10 +65,9 @@ export async function resolvePageMetadata({
   let meta = authoredMeta;
 
   if (needsTemplates && pageData) {
-    const routeTemplateKeys = await listRouteTemplateKeysFromDatabase();
+    const routeTemplateKeys = await loadRouteTemplateKeys();
     const referencedDatasourceIds = extractReferencedDatasourceIds(pageData);
     const context = await loadRemoteDatasourceContext({
-      searchParams,
       fetchImpl: fetch,
       pagePath: path,
       routeTemplateKeys,

package/template/package.json

@@ -15,12 +15,12 @@
   },
   "dependencies": {
     "@pantheon-systems/cpub-react-sdk": "^5.2.1",
-    "@pantheon-systems/css-client": "^0.10.0",
-    "@pantheon-systems/p1-ai-chat": "workspace:*",
-    "@pantheon-systems/p1-media": "workspace:*",
-    "@pantheon-systems/p1-next-sdk": "^0.10.0",
-    "@pantheon-systems/pds-toolkit-react": "2.0.0-alpha.51",
-    "@pantheon-systems/puck-css": "^0.10.0",
+    "@pantheon-systems/css-client": "^0.11.1",
+    "@pantheon-systems/p1-ai-chat": "^0.5.1",
+    "@pantheon-systems/p1-media": "^0.4.4",
+    "@pantheon-systems/p1-next-sdk": "^0.11.1",
+    "@pantheon-systems/pds-toolkit-react": "2.0.0-alpha.66",
+    "@pantheon-systems/puck-css": "^0.11.1",
     "@puckeditor/core": "^0.21.1",
     "@tailwindcss/postcss": "^4.2.2",
     "@tailwindcss/typography": "^0.5.16",