handoff-app 2.0.0-12 → 2.0.0-13

package/src/registry/asset-storage/types.ts

@@ -1,13 +1,13 @@
 /**
- * Server-only asset storage contract for custom {@link defineAssetStorage} object storage modules.
+ * Server-only asset storage contract for custom {@link defineStorageProvider} object storage modules.
  * The built-in `database` provider is the inline default: bytes live in the `asset_blobs.content`
- * bytea column, read/written directly by the registry, so it needs no adapter. Object providers
+ * bytea column, read/written directly by the registry, so it needs no module. Object providers
  * record a `storageRef` + provider id so reads resolve back through whichever provider stored the
  * blob.
  */
 
 /** Input for storing one content-addressed blob. */
-export interface AssetStorageInput {
+export interface StorageInput {
   /** SHA-256 of the bytes (hex), the content identity, usable as a stable object key. */
   hash: string;
   bytes: Buffer;
@@ -19,7 +19,7 @@ export interface AssetStorageInput {
  * How a provider returns stored content: raw bytes, a readable stream, or a signed/redirect URL the
  * client can fetch directly (used to avoid routing large payloads through the serverless function).
  */
-export type AssetStorageReadResult =
+export type StorageReadResult =
   | { kind: 'bytes'; bytes: Buffer; contentType?: string }
   | { kind: 'stream'; stream: NodeJS.ReadableStream; contentType?: string }
   | { kind: 'redirect'; url: string };
@@ -40,10 +40,10 @@ export interface AssetUpload {
   storageRef: string;
 }
 
-/** The pluggable storage adapter contract for object-backed asset providers. */
-export interface AssetStorage {
+/** The pluggable storage contract for object-backed asset providers. */
+export interface StorageProvider {
   /** Store one blob and return the reference to persist on its `asset_blobs` row. */
-  put(input: AssetStorageInput): Promise<{ storageRef: string }>;
+  put(input: StorageInput): Promise<{ storageRef: string }>;
   /**
    * Return a signed URL so the CLI uploads the blob directly to storage instead of through the
    * registry, which avoids serverless request size limits. The URL must make storage reject bytes
@@ -51,18 +51,18 @@ export interface AssetStorage {
    */
   createUpload?(input: AssetUploadInput): Promise<AssetUpload>;
   /** Resolve stored content by its `storageRef`. */
-  get(storageRef: string): Promise<AssetStorageReadResult>;
+  get(storageRef: string): Promise<StorageReadResult>;
   /** Delete stored content by its `storageRef`. Should be retryable/idempotent. */
   delete(storageRef: string): Promise<void>;
 }
 
-/** Context passed to a custom adapter factory: its config options and the process env. */
-export interface AssetStorageContext {
+/** Context passed to a custom provider factory: its config options and the process env. */
+export interface StorageProviderContext {
   /** `runtime.registry.assetStorage.options`, with each `fromEnv()` reference replaced by its value. */
   options: Record<string, unknown>;
   /** The process environment. */
   env: NodeJS.ProcessEnv;
 }
 
-/** A custom adapter may export the adapter directly or a factory that builds it from its context. */
-export type AssetStorageFactory = (context: AssetStorageContext) => AssetStorage | Promise<AssetStorage>;
+/** A custom provider module may export the provider directly or a factory that builds it from its context. */
+export type StorageProviderFactory = (context: StorageProviderContext) => StorageProvider | Promise<StorageProvider>;

package/src/registry/db/schema.ts

@@ -30,7 +30,7 @@ import type { TokenSetKind } from '../tokens/sets';
 
 /**
  * PostgreSQL `bytea` column. Drizzle pg-core has no built-in binary type, so declare it once here.
- * Reads/writes are Node `Buffer`s. The default asset storage adapter keeps small/ordinary asset
+ * Reads/writes are Node `Buffer`s. The default asset storage provider keeps small/ordinary asset
  * bytes inline in this column; larger assets are offloaded to an object-storage `storageRef` instead.
  */
 const bytea = customType<{ data: Buffer; driverData: Buffer }>({
@@ -39,7 +39,7 @@ const bytea = customType<{ data: Buffer; driverData: Buffer }>({
   },
 });
 
-/** Where an asset blob's bytes live: inline in the database (`database`) or in the custom adapter (`custom`). */
+/** Where an asset blob's bytes live: inline in the database (`database`) or in a custom provider (`custom`). */
 export type AssetStorageProvider = 'database' | 'custom';
 import type { ComponentListObject, PageListObject, PatternComponentEntry, PatternListObject } from '../../transformers/preview/types';
 
@@ -432,7 +432,7 @@ export const assets = pgTable(
 /**
  * Content-addressed binary blob store, shared across assets/collections (the `hash` is the blob
  * identity, so an unchanged file re-references the same row). Exactly one location is active per row:
- * inline `content` (bytea, default DB adapter) or an external `storageRef` resolved through the
+ * inline `content` (bytea, default `database` provider) or an external `storageRef` resolved through the
  * recorded `storageProvider`. Both nullable so DB- and object-backed blobs coexist.
  */
 export const assetBlobs = pgTable('asset_blobs', {

package/src/registry/email/define.ts

@@ -1,5 +1,5 @@
 /**
- * Typed identity helper for custom email providers (mirrors `defineAssetStorage`): a consumer
+ * Typed identity helper for custom email providers (mirrors `defineStorageProvider`): a consumer
  * default-exports its result from a **server-only** module and points `runtime.registry.email.module`
  * at it. It must be its own module (not an inline `defineConfig` function) so the build can trace it
  * into the deployed registry. The default export may be the provider object, or a factory

package/src/registry/email/resolve.ts

@@ -1,33 +1,29 @@
 /**
  * Registry email settings resolution.
  *
- * `runtime.registry.email.provider` selects the built-in `resend` or `smtp` provider, or a `custom`
- * module. The build bakes the provider, the module location, and the options. An option literal is
- * baked as it is. An environment reference stays `{ $env }` and is resolved at request time.
+ * `runtime.registry.email.provider` selects the built-in `smtp` provider or a `custom` module. Without
+ * an email block, email delivery is off. The build bakes the provider, the module location, and the
+ * options. An option literal is baked as it is. An environment reference stays `{ $env }` and is
+ * resolved at request time.
  */
 
 import { HandoffConfigError } from '../../config/errors';
 import type { ResolvedConfig } from '../../types/config';
 
-export type EmailProviderKind = 'resend' | 'smtp' | 'custom';
+export type EmailProviderKind = 'smtp' | 'custom';
 
-export const DEFAULT_EMAIL_PROVIDER: EmailProviderKind = 'resend';
-
-/** Default env-var name holding the Resend API key. */
-export const DEFAULT_RESEND_API_KEY_ENV = 'RESEND_API_KEY';
-
-const PROVIDERS: readonly EmailProviderKind[] = ['resend', 'smtp', 'custom'];
+const PROVIDERS: readonly EmailProviderKind[] = ['smtp', 'custom'];
 
 /** The options each built-in provider accepts. A custom provider accepts any. */
 const BUILT_IN_OPTIONS: Record<Exclude<EmailProviderKind, 'custom'>, readonly string[]> = {
-  resend: ['apiKey'],
   smtp: ['host', 'port', 'secure', 'user', 'password'],
 };
 
 /** Email settings as they are baked: literals and `{ $env }` references, never secret values. */
 export interface EmailSettings {
   from?: string;
-  provider: EmailProviderKind;
+  /** Unset when the config has no email block. */
+  provider?: EmailProviderKind;
   /** For `custom`: the server-only provider module path. */
   module?: string;
   options: Record<string, unknown>;
@@ -38,25 +34,30 @@ const isPlainRecord = (value: unknown): value is Record<string, unknown> =>
 
 /** Resolve and validate the email block from a loaded config (CLI/build side). An unusable block fails the build. */
 export const resolveEmailFromConfig = (config: ResolvedConfig | null | undefined): EmailSettings => {
-  const email = config?.runtime?.registry?.email as Record<string, unknown> | undefined;
+  const email = config?.runtime?.registry?.email as unknown as Record<string, unknown> | undefined;
   const fail = (problem: string): never => {
     throw new HandoffConfigError(`Config "runtime.registry.email": ${problem}`);
   };
 
-  const provider = (email?.provider ?? DEFAULT_EMAIL_PROVIDER) as EmailProviderKind;
+  if (email === undefined) return { options: {} };
+  const provider = email.provider as EmailProviderKind;
   if (!PROVIDERS.includes(provider)) {
-    fail(`unknown provider ${JSON.stringify(provider)}. Use "resend", "smtp" or "custom".`);
+    fail(
+      email.provider === undefined
+        ? '"provider" is required. Use "smtp" or "custom".'
+        : `unknown provider ${JSON.stringify(provider)}. Use "smtp" or "custom".`
+    );
   }
-  if (email?.options !== undefined && !isPlainRecord(email.options)) {
+  if (email.options !== undefined && !isPlainRecord(email.options)) {
     fail('"options" must be an object.');
   }
-  const options = { ...((email?.options as Record<string, unknown> | undefined) ?? {}) };
-  const module = typeof email?.module === 'string' ? email.module.trim() : undefined;
+  const options = { ...((email.options as Record<string, unknown> | undefined) ?? {}) };
+  const module = typeof email.module === 'string' ? email.module.trim() : undefined;
 
   if (provider === 'custom') {
     if (!module) fail('provider "custom" needs a "module" that default-exports a defineEmailProvider() result.');
   } else {
-    if (email?.module !== undefined) fail(`"module" is used only by provider "custom", not "${provider}".`);
+    if (email.module !== undefined) fail(`"module" is used only by provider "custom", not "${provider}".`);
     const allowed = BUILT_IN_OPTIONS[provider];
     const unknown = Object.keys(options).filter((key) => !allowed.includes(key));
     if (unknown.length > 0) {
@@ -67,9 +68,8 @@ export const resolveEmailFromConfig = (config: ResolvedConfig | null | undefined
     }
   }
   if (provider === 'smtp' && options.host === undefined) fail('provider "smtp" needs "options.host".');
-  if (provider === 'resend' && options.apiKey === undefined) options.apiKey = { $env: DEFAULT_RESEND_API_KEY_ENV };
 
-  const from = typeof email?.from === 'string' ? email.from.trim() || undefined : undefined;
+  const from = typeof email.from === 'string' ? email.from.trim() || undefined : undefined;
   return { from, provider, ...(module ? { module } : {}), options };
 };
 
@@ -83,11 +83,11 @@ export const parseEmailSettings = (raw: { from?: unknown; provider?: unknown; mo
       options = {};
     }
   }
-  const provider = PROVIDERS.find((kind) => kind === raw.provider) ?? DEFAULT_EMAIL_PROVIDER;
+  const provider = PROVIDERS.find((kind) => kind === raw.provider);
   const module = typeof raw.module === 'string' ? raw.module.trim() : '';
   return {
     from: typeof raw.from === 'string' ? raw.from.trim() || undefined : undefined,
-    provider,
+    ...(provider ? { provider } : {}),
     ...(module ? { module } : {}),
     options: isPlainRecord(options) ? options : {},
   };

package/src/registry/email/types.ts

@@ -1,6 +1,6 @@
 /**
  * Server-only email provider contract. Handoff renders every message, and a provider only delivers it.
- * Resend and SMTP are built in. Anything else is a {@link defineEmailProvider} module.
+ * SMTP is built in. Anything else is a {@link defineEmailProvider} module.
  */
 
 /** One rendered message. */

package/src/store/registry.ts

@@ -16,7 +16,7 @@
 
 import { orderPreviews } from '../catalog/previews';
 import { and, eq, inArray, or, sql, type SQLWrapper } from 'drizzle-orm';
-import type { AssetStorage, AssetStorageReadResult } from '../registry/asset-storage/types';
+import type { StorageProvider, StorageReadResult } from '../registry/asset-storage/types';
 import type { RegistryDatabase } from '../registry/db/client';
 import {
   assetBlobs,
@@ -53,11 +53,11 @@ import type {
 export interface RegistryStoreContext {
   db: RegistryDatabase;
   /**
-   * Resolve the {@link AssetStorage} adapter for a blob's recorded provider (or `null` for the inline
+   * Resolve the {@link StorageProvider} for a blob's recorded provider (or `null` for the inline
    * `database` provider). Injected by the app runtime so `src/store` stays free of app-side imports;
    * when omitted, only inline DB-backed asset content is resolvable.
    */
-  resolveAssetAdapter?: (provider: AssetStorageProvider) => Promise<AssetStorage | null>;
+  resolveStorageProvider?: (provider: AssetStorageProvider) => Promise<StorageProvider | null>;
 }
 
 /** A persisted text-file row, as selected from `component_files`/`pattern_files`. */
@@ -422,14 +422,14 @@ export class RegistryAssetStore implements AssetStore {
     }
 
     // Object-backed - resolve through the provider that stored it.
-    if (!row.storageRef || !this.context.resolveAssetAdapter) {
+    if (!row.storageRef || !this.context.resolveStorageProvider) {
       return null;
     }
-    const adapter = await this.context.resolveAssetAdapter(row.storageProvider);
-    if (!adapter) {
+    const storage = await this.context.resolveStorageProvider(row.storageProvider);
+    if (!storage) {
       return null;
     }
-    const result: AssetStorageReadResult = await adapter.get(row.storageRef);
+    const result: StorageReadResult = await storage.get(row.storageRef);
     if (result.kind === 'redirect') {
       return { ...base, redirectUrl: result.url };
     }

package/src/types/config.ts

@@ -129,16 +129,6 @@ interface HandoffEmailBase {
   from?: string;
 }
 
-/** Send through the Resend HTTP API. */
-export interface HandoffResendEmail extends HandoffEmailBase {
-  /** @default "resend" */
-  provider?: 'resend';
-  options?: {
-    /** Environment reference to the Resend API key. @default fromEnv('RESEND_API_KEY') */
-    apiKey?: RuntimeEnvReference<string>;
-  };
-}
-
 /** Send through an SMTP server, such as Amazon SES, SendGrid, Postmark, Mailgun or Microsoft 365. */
 export interface HandoffSmtpEmail extends HandoffEmailBase {
   provider: 'smtp';
@@ -170,7 +160,7 @@ export interface HandoffCustomEmail extends HandoffEmailBase {
 }
 
 /** Registry email settings. `provider` selects the shape of `options`. */
-export type HandoffEmailConfig = HandoffResendEmail | HandoffSmtpEmail | HandoffCustomEmail;
+export type HandoffEmailConfig = HandoffSmtpEmail | HandoffCustomEmail;
 
 /**
  * One AI connection the deployment declares. Connections are the whole surface: a reader can add a
@@ -277,13 +267,13 @@ export interface HandoffRuntimeConfig {
        * `custom` module for object storage.
        * @default "database"
        */
-      adapter?: 'database' | 'custom';
-      /** For `adapter: "custom"` - server-only module path default-exporting a `defineAssetStorage` adapter. */
+      provider?: 'database' | 'custom';
+      /** For `provider: "custom"` - server-only module path default-exporting a `defineStorageProvider()` result. */
       module?: string;
       /** Max bytes kept inline in the database `bytea` column (larger uploads are rejected). @default 4194304 */
       maxInlineBytes?: number;
       /**
-       * Options passed to the adapter factory. Literals are baked. Environment references are resolved
+       * Options passed to the provider factory. Literals are baked. Environment references are resolved
        * at request time, so secrets must be environment references.
        */
       options?: Record<string, unknown>;

package/.editorconfig

@@ -1,19 +0,0 @@
-# EditorConfig is awesome: https://EditorConfig.org
-
-# top-most EditorConfig file
-root = true
-
-[*.{css,scss,sass}]
-charset = utf-8
-indent_style = tab
-indent_size = unset
-end_of_line = lf
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.{js,ts,jsx,tsx}]
-charset = utf-8
-indent_style = space
-end_of_line = lf
-trim_trailing_whitespace = true
-insert_final_newline = true

package/.eslintrc.json

@@ -1,4 +0,0 @@
-{
-  "extends": ["next", "prettier"],
-  "ignorePatterns": ["./src/app/out/**/*", "**/*.js"]
-}

package/.prettierrc.json

@@ -1,8 +0,0 @@
-{
-    "trailingComma": "es5",
-    "semi": true,
-    "tabWidth": 2,
-    "singleQuote": true,
-    "jsxSingleQuote": true,
-    "plugins": ["prettier-plugin-tailwindcss"]
-  }

package/.vscode/settings.json

@@ -1,17 +0,0 @@
-{
-  "editor.defaultFormatter": "esbenp.prettier-vscode",
-  "[javascript]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
-  "editor.formatOnSave": true,
-  "editor.codeActionsOnSave": {
-    "source.organizeImports": "explicit"
-  },
-  "[xml]": {
-    "editor.defaultFormatter": "redhat.vscode-xml"
-  },
-  "[typescriptreact]": {
-    "editor.defaultFormatter": "vscode.typescript-language-features"
-  },
-  "[markdown]": {
-    "editor.defaultFormatter": "unifiedjs.vscode-remark"
-  }
-}

package/dist/define.d.ts

@@ -1,10 +0,0 @@
-/**
- * Define helpers for custom server modules. This entry point has no runtime dependencies, so a module
- * that imports it does not pull the CLI into the registry bundle.
- */
-export { defineAiProvider } from './ai/define';
-export type { AiProvider, AiProviderContext, AiProviderFactory } from './ai/types';
-export { defineAssetStorage } from './registry/asset-storage/define';
-export type { AssetStorage, AssetStorageContext, AssetStorageFactory, AssetStorageInput, AssetStorageReadResult, AssetUpload, AssetUploadInput, } from './registry/asset-storage/types';
-export { defineEmailProvider } from './registry/email/define';
-export type { EmailMessage, EmailProvider, EmailProviderContext, EmailProviderFactory } from './registry/email/types';

package/dist/registry/email/adapters/resend.d.ts

@@ -1,7 +0,0 @@
-/**
- * Built-in Resend provider, selected with `runtime.registry.email.provider: "resend"` (the default).
- * A plain `fetch` to the Resend HTTP API, so it adds no dependency.
- */
-import type { EmailProvider } from '../types';
-/** Build a Resend provider from options whose references are already resolved. */
-export declare const createResendProvider: (options: Record<string, unknown>) => EmailProvider;

package/dist/registry/email/adapters/resend.js

@@ -1,35 +0,0 @@
-"use strict";
-/**
- * Built-in Resend provider, selected with `runtime.registry.email.provider: "resend"` (the default).
- * A plain `fetch` to the Resend HTTP API, so it adds no dependency.
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createResendProvider = void 0;
-/** Build a Resend provider from options whose references are already resolved. */
-const createResendProvider = (options) => ({
-    send(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ from, to, subject, html, text }) {
-            const apiKey = typeof options.apiKey === 'string' ? options.apiKey : '';
-            if (!apiKey)
-                throw new Error('The Resend API key is not set.');
-            const response = yield fetch('https://api.resend.com/emails', {
-                method: 'POST',
-                headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
-                body: JSON.stringify({ from, to: [to], subject, html, text }),
-            });
-            if (!response.ok) {
-                throw new Error(`Resend rejected the email (HTTP ${response.status}): ${yield response.text()}`);
-            }
-        });
-    },
-});
-exports.createResendProvider = createResendProvider;

package/src/app/components/old/Header.tsx

@@ -1,89 +0,0 @@
-import { ClientConfig } from '@handoff/types/config';
-import Link from 'next/link';
-import React from 'react';
-import NavLink from '../NavLink';
-import { useNav } from '../context/NavProvider';
-
-interface HeaderProps {
-  config: ClientConfig;
-}
-
-function Header({ config }: HeaderProps) {
-  const { menu } = useNav();
-  const [mobile, setMobile] = React.useState('');
-  const toggle = () => {
-    if (mobile === 'is-active') {
-      setMobile('');
-    } else {
-      setMobile('is-active');
-    }
-  };
-
-  return (
-    <>
-      <header id="site-header" className="c-site-header">
-        <div className="o-container-fluid">
-          <div className="c-site-header__wrapper">
-            <div>
-              <div className="c-site-menu">
-                <button className={`c-hamburger-icon c-hamburger-icon--slider ${mobile}`} onClick={toggle}>
-                  <div className="c-hamburger-icon__box">
-                    <div className="c-hamburger-icon__inner"></div>
-                  </div>
-                </button>
-              </div>
-              <div className="c-site-title">
-                <Link href="/" className="c-site-logo c-site-logo--basic" title="" rel="home" aria-label="logo">
-                  {/* eslint-disable-next-line @next/next/no-img-element */}
-                  <img src={`${process.env.HANDOFF_APP_BASE_PATH ?? ''}/logo.svg`} alt={config?.app?.title} />
-                </Link>
-              </div>
-
-              <nav className="c-site-nav">
-                <ul>
-                  {menu.map((item) => (
-                    <li key={item.path}>
-                      <NavLink href={`${item.path}`}>{item.title}</NavLink>
-                    </li>
-                  ))}
-                </ul>
-              </nav>
-            </div>
-            <div>
-              {
-                // TODO: Reimpliment cmd k search
-                false && <small>hit cmd+k to search</small>
-              }
-            </div>
-          </div>
-        </div>
-      </header>
-      <div className={`c-offcanvas c-offcanvas--menu ${mobile}`}>
-        <div className="c-offcanvas__inner">
-          <nav className="c-mobilenav">
-            <ul className="c-mobilenav__menu">
-              {menu.map((item) => (
-                <li key={`mobile-${item.path}`}>
-                  <NavLink href={`${item.path}`}>{item.title}</NavLink>
-                  {item.subSections.length > 0 && (
-                    <ul className="c-mobilenav__submenu">
-                      {item.subSections
-                        .filter((sub) => sub.path)
-                        .map((sub) => (
-                          <li key={sub.path}>
-                            <NavLink href={`${sub.path}`}>{sub.title}</NavLink>
-                          </li>
-                        ))}
-                    </ul>
-                  )}
-                </li>
-              ))}
-            </ul>
-          </nav>
-        </div>
-      </div>
-    </>
-  );
-}
-
-export default Header;

package/src/app/pages/assets/fonts.tsx

@@ -1,129 +0,0 @@
-import * as fs from 'fs-extra';
-import uniq from 'lodash/uniq';
-import { FileArchive } from 'lucide-react';
-import type { GetStaticProps } from 'next';
-import Head from 'next/head';
-import path from 'path';
-import * as React from 'react';
-import ReactMarkdown from 'react-markdown';
-import rehypeRaw from 'rehype-raw';
-import remarkGfm from 'remark-gfm';
-import Footer from '../../components/Footer';
-import { MarkdownComponents, remarkCodeMeta } from '../../components/Markdown/MarkdownComponents';
-import Header from '../../components/old/Header';
-import { buildTimeFoundationDesign, fetchDocPageMarkdown, FontDocumentationProps, getClientRuntimeConfig } from '../../components/util';
-import { useFoundationTokens } from '../../components/util/useFoundationTokens';
-
-const basePath = process.env.HANDOFF_APP_BASE_PATH ?? '';
-const isRegistry = process.env.HANDOFF_RUNTIME_MODE === 'registry';
-
-/**
- * This statically renders content from the markdown, creating menu and providing
- * metadata
- *
- * This is all done statically at build time
- * @param context GetStaticProps
- * @returns
- */
-export const getStaticProps: GetStaticProps = async () => {
-  // Workspace/static reads the mirrored font archives; a registry build has none (hydrated at runtime).
-  const customFonts: string[] = [];
-  try {
-    const fontDir = path.resolve(process.env.HANDOFF_MODULE_PATH ?? '', '.handoff', `${process.env.HANDOFF_PROJECT_ID}`, 'public', 'fonts');
-    for (const font of fs.readdirSync(fontDir)) {
-      if (font.endsWith('.zip')) customFonts.push(font.replace('.zip', ''));
-    }
-  } catch {
-    // No local font archives (e.g. a registry build), so customFonts stays empty.
-  }
-
-  return {
-    props: {
-      ...(await fetchDocPageMarkdown('docs/assets/', 'fonts', `/assets`)).props,
-      design: buildTimeFoundationDesign(),
-      config: getClientRuntimeConfig(),
-      customFonts,
-    },
-  };
-};
-
-const FontsPage = ({ content, menu, metadata, customFonts, design, config }: FontDocumentationProps) => {
-  // Registry hydrates typography tokens (for the family list) + the published font archives at runtime.
-  const tokens = useFoundationTokens('typography', { design });
-  const [hydratedFonts, setHydratedFonts] = React.useState<string[]>(customFonts);
-  React.useEffect(() => {
-    if (!isRegistry) return;
-    let active = true;
-    fetch(`${basePath}/api/docs/assets/fonts`)
-      .then((res) => (res.ok ? res.json() : null))
-      .then((data) => {
-        if (!active || !data?.assets) return;
-        const names = (data.assets as { path: string }[])
-          .filter((a) => typeof a.path === 'string' && /^fonts\/.+\.zip$/i.test(a.path))
-          .map((a) => a.path.slice('fonts/'.length).replace(/\.zip$/i, ''));
-        setHydratedFonts(names);
-      })
-      .catch(() => {});
-    return () => {
-      active = false;
-    };
-  }, []);
-
-  const typography = tokens.design?.typography ?? [];
-  const fontFamilies: string[] = uniq(typography.map((type) => type.values.fontFamily));
-  const fontLinks: string[] = fontFamilies.map((fontFamily) => {
-    const machineName = fontFamily.replace(/\s/g, '');
-    const custom = hydratedFonts.find((font) => font === machineName);
-    if (custom) {
-      return isRegistry ? `${basePath}/api/docs/assets/fonts/fonts/${machineName}.zip` : `/fonts/${machineName}.zip`;
-    }
-    return `https://fonts.google.com/specimen/${fontFamily}`;
-  });
-  return (
-    <div className="c-page">
-      <Head>
-        <title>{metadata.metaTitle}</title>
-        <meta name="description" content={metadata.metaDescription} />
-      </Head>
-      <Header config={config} />
-      <section className="c-content">
-        <div className="o-container-fluid">
-          <div className="c-hero">
-            <div>
-              <h1>{metadata.title}</h1>
-              <p>{metadata.description}</p>
-            </div>
-          </div>
-          {fontFamilies.map((fontFamily, i) => (
-            <React.Fragment key={fontFamily}>
-              <div className="o-row u-justify-between">
-                <div className="o-col-5@md">
-                  <h4>{fontFamily}</h4>
-                </div>
-                <div className="o-col-6@md">
-                  <div className="c-card">
-                    <FileArchive />
-                    <h4>{fontFamily}</h4>
-                    <p>Font files for installing on a local machine.</p>
-                    <p>
-                      <a href={fontLinks[i]}>Download Font</a>
-                    </p>
-                  </div>
-                </div>
-              </div>
-              <hr />
-            </React.Fragment>
-          ))}
-
-          <div className="prose">
-            <ReactMarkdown components={MarkdownComponents} remarkPlugins={[remarkGfm, remarkCodeMeta]} rehypePlugins={[rehypeRaw]}>
-              {content}
-            </ReactMarkdown>
-          </div>
-        </div>
-      </section>
-      <Footer config={config} />
-    </div>
-  );
-};
-export default FontsPage;