@gigamusic/links 0.3.0 → 2.0.0

package/README.md

@@ -1,34 +1,66 @@
 # @gigamusic/links
 
-Linktree-style per-release link pages for `@gigamusic/*` artist sites. Ships its own Prisma fragment (`LinkPage`, `LinkPageItem`), a public `LinkPageView` component, admin page bodies + form, admin API handler factories, and platform-detection helpers.
-
-## Install
+Linktree-style per-release link pages for the gigamusic platform. Ships a Drizzle schema (`linkPages`, `linkPageItems`), a typed queries factory, admin API handler factories, platform-detection helpers, and a small SVG `LinkPlatformIcon` component.
 
 ```ts
 import {
   createLinkPageQueries,
-  LinkPageView,
-  createPublicLinkPage,
-  createAdminLinkPagesHandlers,
   detectLinkPlatform,
+  PLATFORM_LABELS,
   LinkPlatformIcon,
+  type KnownLinkPlatform,
 } from "@gigamusic/links";
+
+// Admin handler factories live on the /server subpath
+import {
+  createAdminLinkPagesHandlers,
+  createAdminLinkPageByIdHandlers,
+  createAdminLinkPageItemsHandlers,
+} from "@gigamusic/links/server";
 ```
 
-The package is source-shipped — add `@gigamusic/links` to `transpilePackages` in your `next.config.ts` (the create-gigamusic-app scaffold does this automatically).
+The public link-page UI is the consumer's responsibility — fetch with `createLinkPageQueries(db).getPublicLinkPageBySlug(slug)` and render whatever you want.
 
-## Prisma fragment
+## Schema subpath
 
-Run `gigamusic-links sync` to copy the `link-page.prisma` fragment into `prisma/schema/20-link-page.prisma`. Run after every `@gigamusic/links` upgrade; `gigamusic-links doctor` checks for staleness.
+`@gigamusic/links/schema` exports the table objects and relations:
+
+```ts
+import {
+  linkPages,
+  linkPageItems,
+  linkPagesRelations,
+  linkPageItemsRelations,
+  linkPageColumns,
+  linkPageItemColumns,
+} from "@gigamusic/links/schema";
+```
 
-The fragment references the `Release` model owned by `@gigamusic/db`. Prisma requires both sides of a relation to be declared, so consumers must add the inverse on their copy of `Release`:
+Merge with `@gigamusic/db/schema` when constructing your Drizzle instance:
+
+```ts
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+import * as dbSchema from "@gigamusic/db/schema";
+import * as linksSchema from "@gigamusic/links/schema";
+
+const schema = { ...dbSchema, ...linksSchema };
+export const db = drizzle(new Pool({ connectionString: process.env.DATABASE_URL }), { schema });
+```
+
+## Release back-reference
+
+`linkPages.releaseId` is a nullable FK to `releases.id` from `@gigamusic/db`. Drizzle relations are declared independently on each side, so this package's `linkPagesRelations` already declares the `linkPage.release` direction. If you want a `release.linkPages` back-reference (for `db.query.releases.findFirst({ with: { linkPages: true } })`), add it in your own schema file by composing onto the base `releasesRelations`:
+
+```ts
+import { relations } from "drizzle-orm";
+import { releases } from "@gigamusic/db/schema";
+import { linkPages } from "@gigamusic/links/schema";
 
-```prisma
-// prisma/schema/99-app.prisma (or wherever your Release lives)
-model Release {
-  // ...existing fields...
-  linkPages LinkPage[]
-}
+export const releasesRelations = relations(releases, ({ many }) => ({
+  // ...keep the existing many() relations from @gigamusic/db/schema if you need them...
+  linkPages: many(linkPages),
+}));
 ```
 
-If your `Release` is shipped verbatim from `@gigamusic/db`'s `10-release.prisma`, add a thin override file at `99-release-link-pages.prisma` that re-declares the model with the extra field, or extend the upstream fragment when re-syncing.
+Because relations are TS modules, you compose them once and never re-apply patches on package upgrades.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gigamusic/links",
-  "version": "0.3.0",
-  "description": "Editable Linktree-style link pages for gigamusic artist sites. Ships a Prisma fragment, public + admin React components, admin API handler factories, and platform-detection helpers.",
+  "version": "2.0.0",
+  "description": "Editable Linktree-style link pages for gigamusic artist sites. Ships a Drizzle schema, admin API handler factories, and platform-detection helpers.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -9,68 +9,53 @@
     "directory": "packages/links"
   },
   "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
   "exports": {
     ".": {
       "types": "./src/index.ts",
       "default": "./src/index.ts"
     },
-    "./client": {
-      "types": "./src/client.ts",
-      "default": "./src/client.ts"
-    },
     "./server": {
       "types": "./src/server.ts",
       "default": "./src/server.ts"
+    },
+    "./schema": {
+      "types": "./src/schema/index.ts",
+      "default": "./src/schema/index.ts"
     }
   },
-  "bin": {
-    "gigamusic-links": "./dist/cli.js"
-  },
   "files": [
     "src",
-    "prisma",
-    "dist",
     "README.md"
   ],
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@gigamusic/db": "0.3.0",
-    "@gigamusic/config": "0.3.0",
-    "@gigamusic/ui": "0.3.0",
-    "@gigamusic/core": "0.3.0"
+    "@gigamusic/core": "1.0.0",
+    "@gigamusic/db": "2.0.0"
   },
   "peerDependencies": {
-    "@prisma/client": ">=6",
+    "drizzle-orm": ">=0.45",
     "next": ">=15",
     "react": ">=18 <20",
     "react-dom": ">=18 <20"
   },
   "devDependencies": {
-    "@prisma/client": "^6.1.0",
-    "@testing-library/dom": "^10.4.0",
-    "@testing-library/react": "^16.1.0",
     "@types/node": "^22.10.5",
+    "@types/pg": "^8.11.10",
     "@types/react": "^19.0.0",
-    "@types/react-dom": "^19.0.0",
-    "jsdom": "^25.0.1",
+    "drizzle-kit": "^0.31.10",
+    "drizzle-orm": "^0.45.2",
     "next": "^16.0.0",
+    "pg": "^8.21.0",
     "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "tsup": "^8.3.5",
     "typescript": "^5.7.3",
     "vitest": "^2.1.8"
   },
   "scripts": {
-    "build": "pnpm run prisma:generate && tsup",
-    "dev": "tsup --watch",
     "lint": "eslint src",
-    "test": "pnpm run prisma:generate && vitest run",
-    "typecheck": "pnpm run prisma:generate && tsc --noEmit",
-    "prisma:generate": "prisma generate --schema=./prisma",
-    "clean": "rm -rf dist .turbo *.tsbuildinfo"
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf .turbo *.tsbuildinfo"
   }
 }

package/src/index.ts

@@ -1,5 +1,5 @@
-// Server-safe public entry. Everything that requires the React client runtime
-// (context providers, the form components, etc.) lives in `./client`.
+// Public entry — server-safe types, queries, and platform helpers.
+// Admin handler factories live on the `./server` subpath.
 
 // ── Types ────────────────────────────────────────────────────────────────
 export type {
@@ -14,62 +14,13 @@ export type {
 
 // ── Queries factory ─────────────────────────────────────────────────────
 export { createLinkPageQueries } from "./queries/link-pages";
+export type { LinkPagesDb } from "./queries/link-pages";
 
 // ── Platform detection ──────────────────────────────────────────────────
 export { detectLinkPlatform, PLATFORM_LABELS } from "./platforms/detect";
 export type { KnownLinkPlatform } from "./platforms/detect";
 export { LinkPlatformIcon } from "./platforms/icon";
 
-// ── Slots ────────────────────────────────────────────────────────────────
-export type {
-  LinksSlots,
-  LinkButtonProps,
-  LinkPageHeaderProps,
-} from "./slots";
-
-// ── Public render surface ───────────────────────────────────────────────
-export { LinkPageView } from "./components/LinkPageView";
-export { DefaultLinkButton } from "./components/LinkButton";
-export { DefaultLinkPageHeader } from "./components/LinkPageHeader";
-
-// ── Public page (per-slug landing) ──────────────────────────────────────
-export {
-  PublicLinkPage,
-  createPublicLinkPage,
-  createPublicLinkPageMetadata,
-  publicLinkPageMetadata,
-  registerLinkPageMetadata,
-} from "./pages/PublicLinkPage";
-export type {
-  PublicLinkPageProps,
-  CreatePublicLinkPageDeps,
-  PublicLinkPageMetadataDeps,
-  PublicLinkPageMetadataArgs,
-} from "./pages/PublicLinkPage";
-
-// ── Admin page bodies ───────────────────────────────────────────────────
-export {
-  AdminLinkPagesIndexPage,
-  createAdminLinkPagesIndexPage,
-} from "./pages/AdminLinkPagesIndexPage";
-export type { AdminLinkPagesIndexPageProps } from "./pages/AdminLinkPagesIndexPage";
-export { AdminNewLinkPagePage } from "./pages/AdminNewLinkPagePage";
-export type { AdminNewLinkPagePageProps } from "./pages/AdminNewLinkPagePage";
-export { AdminEditLinkPagePage } from "./pages/AdminEditLinkPagePage";
-export type { AdminEditLinkPagePageProps } from "./pages/AdminEditLinkPagePage";
-
-// ── Admin form types (so consumers can build their own page wrappers) ───
-export type {
-  LinkPageFormPage,
-  LinkPageFormItem,
-  LinkPageFormReleaseOption,
-} from "./components/admin/LinkPageForm";
-export type { NewLinkPageReleaseOption } from "./components/admin/NewLinkPageForm";
-
-// Admin API handler factories live on the `./server` subpath — they import
-// `next/cache`, which Webpack/Turbopack refuse to bundle into a client tree.
-// Use `import { createAdminLinkPagesHandlers } from "@gigamusic/links/server"`.
-
 // ── Slug validation helpers ─────────────────────────────────────────────
 export {
   SLUG_PATTERN,

package/src/platforms/detect.ts

@@ -1,6 +1,13 @@
-import type { KnownPlatform } from "@gigamusic/config";
-
-export type KnownLinkPlatform = KnownPlatform;
+export type KnownLinkPlatform =
+  | "spotify"
+  | "apple-music"
+  | "youtube"
+  | "soundcloud"
+  | "instagram"
+  | "facebook"
+  | "tiktok"
+  | "x"
+  | "bandcamp";
 
 interface HostPattern {
   platform: KnownLinkPlatform;

package/src/queries/link-pages.ts

@@ -1,4 +1,8 @@
-import type { PrismaClient } from "@prisma/client";
+import { and, asc, desc, eq, max } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type * as gigamusicDbSchema from "@gigamusic/db/schema";
+import type * as linksSchema from "../schema/index.js";
+import { linkPageItems, linkPages } from "../schema/index.js";
 import type {
   LinkPage,
   LinkPageInput,
@@ -8,38 +12,42 @@ import type {
   LinkPageWithItems,
 } from "../types";
 
+type RequiredSchema = typeof gigamusicDbSchema & typeof linksSchema;
+
+/** Drizzle DB type the link-pages factory needs — a superset that includes both link-pages tables and `releases`. */
+export type LinkPagesDb = NodePgDatabase<RequiredSchema>;
+
 /**
- * Factory that binds a `PrismaClient` into the `LinkPageQueries` contract.
+ * Factory that binds a Drizzle database into the `LinkPageQueries` contract.
  * Consumers typically merge the result with `@gigamusic/db`'s `createQueries`.
  *
- * Both inputs and outputs use numeric IDs, matching the underlying
- * `Int @id @default(autoincrement())` schema fragments.
+ * The `db` instance must have been built with a schema that includes the
+ * union of `@gigamusic/db/schema` and `@gigamusic/links/schema`; otherwise
+ * the relational `with: { release: ... }` clause won't resolve at runtime.
  */
-export function createLinkPageQueries(db: PrismaClient): LinkPageQueries {
+export function createLinkPageQueries(db: LinkPagesDb): LinkPageQueries {
   return {
     listPublishedLinkPages: async (): Promise<LinkPage[]> => {
-      const rows = await db.linkPage.findMany({
-        where: { isPublished: true },
-        orderBy: { updatedAt: "desc" },
+      const rows = await db.query.linkPages.findMany({
+        where: eq(linkPages.isPublished, true),
+        orderBy: desc(linkPages.updatedAt),
       });
-      return rows as unknown as LinkPage[];
+      return rows;
     },
 
     listAllLinkPages: async (): Promise<LinkPage[]> => {
-      const rows = await db.linkPage.findMany({
-        orderBy: { updatedAt: "desc" },
+      const rows = await db.query.linkPages.findMany({
+        orderBy: desc(linkPages.updatedAt),
       });
-      return rows as unknown as LinkPage[];
+      return rows;
     },
 
-    getPublicLinkPageBySlug: async (
-      slug: string,
-    ): Promise<LinkPageWithItems | null> => {
-      const row = await db.linkPage.findFirst({
-        where: { slug, isPublished: true },
-        include: {
+    getPublicLinkPageBySlug: async (slug: string): Promise<LinkPageWithItems | null> => {
+      const row = await db.query.linkPages.findFirst({
+        where: and(eq(linkPages.slug, slug), eq(linkPages.isPublished, true)),
+        with: {
           release: {
-            select: {
+            columns: {
               id: true,
               name: true,
               slug: true,
@@ -48,20 +56,20 @@ export function createLinkPageQueries(db: PrismaClient): LinkPageQueries {
             },
           },
           items: {
-            where: { isVisible: true },
-            orderBy: { position: "asc" },
+            where: eq(linkPageItems.isVisible, true),
+            orderBy: asc(linkPageItems.position),
           },
         },
       });
-      return row as unknown as LinkPageWithItems | null;
+      return (row ?? null) as unknown as LinkPageWithItems | null;
     },
 
     getLinkPageById: async (id: number): Promise<LinkPageWithItems | null> => {
-      const row = await db.linkPage.findUnique({
-        where: { id },
-        include: {
+      const row = await db.query.linkPages.findFirst({
+        where: eq(linkPages.id, id),
+        with: {
           release: {
-            select: {
+            columns: {
               id: true,
               name: true,
               slug: true,
@@ -69,67 +77,60 @@ export function createLinkPageQueries(db: PrismaClient): LinkPageQueries {
               isPublished: true,
             },
           },
-          items: { orderBy: { position: "asc" } },
+          items: { orderBy: asc(linkPageItems.position) },
         },
       });
-      return row as unknown as LinkPageWithItems | null;
+      return (row ?? null) as unknown as LinkPageWithItems | null;
     },
 
     createLinkPage: async (input: LinkPageInput): Promise<LinkPage> => {
-      const row = await db.linkPage.create({
-        data: {
+      const [row] = await db
+        .insert(linkPages)
+        .values({
           title: input.title,
           slug: input.slug,
           description: input.description ?? null,
           releaseId: input.releaseId ?? null,
           coverImageUrl: input.coverImageUrl ?? null,
           isPublished: input.isPublished ?? true,
-        },
-      });
-      return row as unknown as LinkPage;
+        })
+        .returning();
+      return row!;
     },
 
-    updateLinkPage: async (
-      id: number,
-      input: Partial<LinkPageInput>,
-    ): Promise<LinkPage> => {
+    updateLinkPage: async (id: number, input: Partial<LinkPageInput>): Promise<LinkPage> => {
       const data: Record<string, unknown> = {};
       if (input.title !== undefined) data.title = input.title;
       if (input.slug !== undefined) data.slug = input.slug;
       if (input.description !== undefined) data.description = input.description;
       if (input.releaseId !== undefined) data.releaseId = input.releaseId;
-      if (input.coverImageUrl !== undefined)
-        data.coverImageUrl = input.coverImageUrl;
+      if (input.coverImageUrl !== undefined) data.coverImageUrl = input.coverImageUrl;
       if (input.isPublished !== undefined) data.isPublished = input.isPublished;
-      const row = await db.linkPage.update({
-        where: { id },
-        data,
-      });
-      return row as unknown as LinkPage;
+      const [row] = await db.update(linkPages).set(data).where(eq(linkPages.id, id)).returning();
+      return row!;
     },
 
     deleteLinkPage: async (id: number): Promise<void> => {
-      await db.linkPage.delete({ where: { id } });
+      await db.delete(linkPages).where(eq(linkPages.id, id));
     },
 
-    addLinkPageItem: async (
-      pageId: number,
-      input: LinkPageItemInput,
-    ): Promise<LinkPageItem> => {
-      const max = await db.linkPageItem.aggregate({
-        where: { pageId },
-        _max: { position: true },
-      });
-      const row = await db.linkPageItem.create({
-        data: {
+    addLinkPageItem: async (pageId: number, input: LinkPageItemInput): Promise<LinkPageItem> => {
+      const [maxRow] = await db
+        .select({ max: max(linkPageItems.position) })
+        .from(linkPageItems)
+        .where(eq(linkPageItems.pageId, pageId));
+      const nextPosition = input.position ?? ((maxRow?.max ?? -1) + 1);
+      const [row] = await db
+        .insert(linkPageItems)
+        .values({
           pageId,
           title: input.title,
           url: input.url,
-          position: input.position ?? (max._max.position ?? -1) + 1,
+          position: nextPosition,
           isVisible: input.isVisible ?? true,
-        },
-      });
-      return row as unknown as LinkPageItem;
+        })
+        .returning();
+      return row!;
     },
 
     updateLinkPageItem: async (
@@ -141,15 +142,12 @@ export function createLinkPageQueries(db: PrismaClient): LinkPageQueries {
       if (input.url !== undefined) data.url = input.url;
       if (input.position !== undefined) data.position = input.position;
       if (input.isVisible !== undefined) data.isVisible = input.isVisible;
-      const row = await db.linkPageItem.update({
-        where: { id },
-        data,
-      });
-      return row as unknown as LinkPageItem;
+      const [row] = await db.update(linkPageItems).set(data).where(eq(linkPageItems.id, id)).returning();
+      return row!;
     },
 
     deleteLinkPageItem: async (id: number): Promise<void> => {
-      await db.linkPageItem.delete({ where: { id } });
+      await db.delete(linkPageItems).where(eq(linkPageItems.id, id));
     },
 
     /**
@@ -158,18 +156,15 @@ export function createLinkPageQueries(db: PrismaClient): LinkPageQueries {
      * their current position — callers must include the full set to fully
      * resort.
      */
-    reorderLinkPageItems: async (
-      pageId: number,
-      orderedItemIds: number[],
-    ): Promise<void> => {
-      await db.$transaction(
-        orderedItemIds.map((itemId, position) =>
-          db.linkPageItem.update({
-            where: { id: itemId, pageId },
-            data: { position },
-          }),
-        ),
-      );
+    reorderLinkPageItems: async (pageId: number, orderedItemIds: number[]): Promise<void> => {
+      await db.transaction(async (tx) => {
+        for (let position = 0; position < orderedItemIds.length; position++) {
+          await tx
+            .update(linkPageItems)
+            .set({ position })
+            .where(and(eq(linkPageItems.id, orderedItemIds[position]!), eq(linkPageItems.pageId, pageId)));
+        }
+      });
     },
   };
 }

package/src/schema/index.ts

@@ -0,0 +1,2 @@
+export * from "./link-pages.js";
+export * from "./relations.js";

package/src/schema/link-pages.ts

@@ -0,0 +1,41 @@
+import { boolean, index, integer, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { releases } from "@gigamusic/db/schema";
+
+export const linkPageColumns = {
+  id: integer().primaryKey().generatedAlwaysAsIdentity(),
+  slug: text("slug").notNull().unique(),
+  title: text("title").notNull(),
+  description: text("description"),
+  coverImageUrl: text("coverImageUrl"),
+  releaseId: integer("releaseId").references(() => releases.id, { onDelete: "set null" }),
+  isPublished: boolean("isPublished").notNull().default(true),
+  createdAt: timestamp("createdAt", { mode: "date", precision: 3 }).notNull().defaultNow(),
+  updatedAt: timestamp("updatedAt", { mode: "date", precision: 3 })
+    .notNull()
+    .$defaultFn(() => new Date())
+    .$onUpdateFn(() => new Date()),
+} as const;
+
+export const linkPages = pgTable("link_pages", linkPageColumns, (t) => [
+  index("link_pages_releaseId_idx").on(t.releaseId),
+]);
+
+export const linkPageItemColumns = {
+  id: integer().primaryKey().generatedAlwaysAsIdentity(),
+  pageId: integer("pageId")
+    .notNull()
+    .references(() => linkPages.id, { onDelete: "cascade" }),
+  title: text("title").notNull(),
+  url: text("url").notNull(),
+  position: integer("position").notNull().default(0),
+  isVisible: boolean("isVisible").notNull().default(true),
+  createdAt: timestamp("createdAt", { mode: "date", precision: 3 }).notNull().defaultNow(),
+  updatedAt: timestamp("updatedAt", { mode: "date", precision: 3 })
+    .notNull()
+    .$defaultFn(() => new Date())
+    .$onUpdateFn(() => new Date()),
+} as const;
+
+export const linkPageItems = pgTable("link_page_items", linkPageItemColumns, (t) => [
+  index("link_page_items_pageId_idx").on(t.pageId),
+]);

package/src/schema/relations.ts

@@ -0,0 +1,12 @@
+import { relations } from "drizzle-orm";
+import { releases } from "@gigamusic/db/schema";
+import { linkPages, linkPageItems } from "./link-pages.js";
+
+export const linkPagesRelations = relations(linkPages, ({ one, many }) => ({
+  release: one(releases, { fields: [linkPages.releaseId], references: [releases.id] }),
+  items: many(linkPageItems),
+}));
+
+export const linkPageItemsRelations = relations(linkPageItems, ({ one }) => ({
+  page: one(linkPages, { fields: [linkPageItems.pageId], references: [linkPages.id] }),
+}));

package/src/server.ts

@@ -3,6 +3,7 @@
 // because the handlers depend on `next/cache`.
 
 export { createLinkPageQueries } from "./queries/link-pages";
+export type { LinkPagesDb } from "./queries/link-pages";
 export {
   createAdminLinkPagesHandlers,
   createAdminLinkPageByIdHandlers,
@@ -13,10 +14,3 @@ export type {
   LinkPagesAdminDeps,
   RouteHandler,
 } from "./api/handlers";
-export {
-  PublicLinkPage,
-  createPublicLinkPage,
-  createPublicLinkPageMetadata,
-  publicLinkPageMetadata,
-  registerLinkPageMetadata,
-} from "./pages/PublicLinkPage";

package/src/types.ts

@@ -1,18 +1,10 @@
 import type { LinkPageInput, LinkPageItemInput } from "@gigamusic/core";
+import type { linkPageItems, linkPages } from "./schema/index.js";
 
 export type { LinkPageInput, LinkPageItemInput };
 
 /** A single link button rendered inside a `LinkPage`. */
-export interface LinkPageItem {
-  id: number;
-  pageId: number;
-  title: string;
-  url: string;
-  position: number;
-  isVisible: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-}
+export type LinkPageItem = typeof linkPageItems.$inferSelect;
 
 /** Optional `Release` reference exposed to the public view for cover fallback. */
 export interface LinkPageReleaseRef {
@@ -23,18 +15,8 @@ export interface LinkPageReleaseRef {
   isPublished: boolean;
 }
 
-/** Top-level "Linktree-style" page row. IDs are native `Int @id @default(autoincrement())`. */
-export interface LinkPage {
-  id: number;
-  slug: string;
-  title: string;
-  description: string | null;
-  coverImageUrl: string | null;
-  releaseId: number | null;
-  isPublished: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-}
+/** Top-level "Linktree-style" page row. */
+export type LinkPage = typeof linkPages.$inferSelect;
 
 /** A `LinkPage` joined with its visible (or all) items and an optional release ref. */
 export interface LinkPageWithItems extends LinkPage {
@@ -43,7 +25,7 @@ export interface LinkPageWithItems extends LinkPage {
 }
 
 /**
- * Query helpers that close over a `PrismaClient`. Consumers merge this with
+ * Query helpers that close over a Drizzle DB. Consumers merge this with
  * `@gigamusic/db`'s `Queries` factory result (or pass it through wherever a
  * `LinkPageQueries` is needed).
  */