handoff-app 2.0.0-11 → 2.0.0-13

package/src/app/pages/system/pattern/[pattern]/index.tsx

@@ -130,7 +130,7 @@ export const getStaticProps = async (context: { params: IParams }) => {
       metadata: {
         title: fallbackTitle,
         description: patternData?.description || '',
-        metaTitle: `${fallbackTitle}${config?.app?.client ? ` | ${config.app.client} Design System` : ''}`,
+        metaTitle: '',
         metaDescription: patternData?.description || '',
       },
       previousPattern,
@@ -189,7 +189,7 @@ const PatternPage = ({ menu, metadata, current, id, config, previousPattern, nex
 
   if (patternNotFound) {
     return (
-      <Layout config={config} menu={menu} current={current} metadata={{ ...metadata, title: '404 - Page Not Found', metaTitle: '404 - Page Not Found' }}>
+      <Layout config={config} menu={menu} current={current} metadata={{ ...metadata, title: 'Page Not Found', metaTitle: '' }}>
         <div className="flex min-h-[60vh] flex-col items-center justify-center">
           <NotFound />
         </div>

package/src/app/pages/system/tokens/components/[component]/index.tsx

@@ -70,14 +70,10 @@ export const getStaticProps = async (context) => {
     description = componentData?.description;
   }
 
-  const fallbackTitle = displayName || startCase(componentSlug);
-  const fallbackMetaTitle = `${fallbackTitle}${config?.app?.client ? ` | ${config.app.client} Design System` : ''}`;
-
   markdownProps.metadata = {
     ...markdownProps.metadata,
     title: displayName || markdownProps.metadata.title || startCase(componentSlug),
     description: markdownProps.metadata.description || description || '',
-    metaTitle: markdownProps.metadata.metaTitle || fallbackMetaTitle,
     metaDescription: markdownProps.metadata.metaDescription || description || '',
   };
 

package/src/app-builder/build.ts

@@ -300,14 +300,14 @@ const initializeProjectApp = async (handoff: Handoff, options: InitializeProject
   const escapedMcpEnabled = escapeForSingleQuotedJsString(String(isMcpEnabled(handoff.config)));
   const escapedRegistryDriver = escapeForSingleQuotedJsString(resolveRegistryDriver(handoff.config));
   const escapedDatabaseUrlEnv = escapeForSingleQuotedJsString(resolveDatabaseUrlEnv(handoff.config));
-  // Asset storage selection baked (adapter + module + options JSON with `{ $env }` references).
+  // Asset storage selection baked (provider + module + options JSON with `{ $env }` references).
   const assetStorage = resolveAssetStorageFromConfig(handoff.config);
-  const escapedAssetStorageAdapter = escapeForSingleQuotedJsString(assetStorage.adapterKind);
+  const escapedAssetStorageProvider = escapeForSingleQuotedJsString(assetStorage.provider);
   const escapedAssetStorageModule = escapeForSingleQuotedJsString(assetStorage.module ?? '');
   const escapedAssetStorageMaxInline = escapeForSingleQuotedJsString(String(assetStorage.maxInlineBytes));
   const escapedAssetStorageOptions = escapeForSingleQuotedJsString(JSON.stringify(assetStorage.options ?? {}));
   const email = resolveEmailFromConfig(handoff.config);
-  const escapedEmailProvider = escapeForSingleQuotedJsString(email.provider);
+  const escapedEmailProvider = escapeForSingleQuotedJsString(email.provider ?? '');
   const escapedEmailFrom = escapeForSingleQuotedJsString(email.from ?? '');
   const escapedEmailModule = escapeForSingleQuotedJsString(email.module ?? '');
   const escapedEmailOptions = escapeForSingleQuotedJsString(JSON.stringify(email.options));
@@ -330,7 +330,7 @@ const initializeProjectApp = async (handoff: Handoff, options: InitializeProject
     '%HANDOFF_MCP_ENABLED%': escapedMcpEnabled,
     '%HANDOFF_REGISTRY_DRIVER%': escapedRegistryDriver,
     '%HANDOFF_REGISTRY_DATABASE_URL_ENV%': escapedDatabaseUrlEnv,
-    '%HANDOFF_ASSET_STORAGE_ADAPTER%': escapedAssetStorageAdapter,
+    '%HANDOFF_ASSET_STORAGE_PROVIDER%': escapedAssetStorageProvider,
     '%HANDOFF_ASSET_STORAGE_MODULE%': escapedAssetStorageModule,
     '%HANDOFF_ASSET_STORAGE_MAX_INLINE_BYTES%': escapedAssetStorageMaxInline,
     '%HANDOFF_ASSET_STORAGE_OPTIONS%': escapedAssetStorageOptions,
@@ -474,7 +474,7 @@ merged over the list this build baked in, keyed by \`id\`. Use it to add or repo
 without rebuilding.
 `;
 
-  const assetStorageEnvs = assetStorage.adapterKind === 'custom' ? envReferenceNames(assetStorage.options) : [];
+  const assetStorageEnvs = assetStorage.provider === 'custom' ? envReferenceNames(assetStorage.options) : [];
   const emailEnvs = envReferenceNames(email.options);
   const emailSection = !email.from
     ? 'Email delivery is off because `runtime.registry.email.from` is not set. Invitation links are shown once to an administrator for manual delivery.'
@@ -498,7 +498,7 @@ and \`.next/static/\` already copied alongside so the server serves them.
 - \`${databaseUrlEnv}\` — PostgreSQL/Neon connection string, read at request time.
 - \`AUTH_SECRET\` — a long, random secret used to sign browser sessions.
 - \`AUTH_URL\` — the canonical public registry URL, including the configured base path.
-${assetStorageEnvs.map((name) => `- \`${name}\` — read by the custom asset storage adapter at request time.\n`).join('')}
+${assetStorageEnvs.map((name) => `- \`${name}\` — read by the custom asset storage provider at request time.\n`).join('')}
 ${emailSection}
 ${aiSection}
 ## Database migrations
@@ -569,8 +569,8 @@ For multi-instance self-hosting, front \`/_next/static\` with a CDN and configur
 
 ## Deploying to Vercel
 
-Vercel does **not** use \`output: 'standalone'\` — it ignores that setting and builds with its own
-adapter, so this pre-built bundle is **not** the artifact you deploy there. For Vercel, deploy the
+Vercel does **not** use \`output: 'standalone'\` — it ignores that setting and runs its
+own build, so this pre-built bundle is **not** the artifact you deploy there. For Vercel, deploy the
 registry app via Vercel's Git/CLI source build (it produces and serves the dynamic app itself) and
 supply the same environment variables above as project env vars. Use this standalone bundle for
 containers, custom Node servers, and other non-Vercel hosts.
@@ -582,7 +582,7 @@ containers, custom Node servers, and other non-Vercel hosts.
  * Resolve the set of npm packages the packaged registry app must be able to `require`/`import` at
  * runtime, given the configured database driver. `next`/`react`/`react-dom` run the server and React
  * runtime; `drizzle-orm` backs both the request-time DB client and the migration runner; the MCP SDK
- * (and its `zod` peer) is only needed when `/api/mcp/` is enabled; the driver package is
+ * is only needed when `/api/mcp/` is enabled; the driver package is
  * driver-specific (the Neon serverless driver also needs `ws` for its Node WebSocket transport); the
  * SMTP email provider needs `nodemailer`.
  */
@@ -592,7 +592,7 @@ const getRequiredRegistryRuntimeModules = (handoff: Handoff): string[] => {
   // The assistant runs the MCP tools in-process, so it needs the MCP SDK whether or not the HTTP
   // endpoint is served.
   if (isMcpEnabled(handoff.config) || ai.enabled) {
-    base.push('@modelcontextprotocol/sdk', 'zod');
+    base.push('@modelcontextprotocol/sdk');
   }
   if (ai.enabled) {
     base.push('ai', '@ai-sdk/openai-compatible');
@@ -635,7 +635,7 @@ const getCustomServerModules = (handoff: Handoff): string[] => {
   const assetStorage = resolveAssetStorageFromConfig(handoff.config);
   const email = resolveEmailFromConfig(handoff.config);
   const modules = [
-    assetStorage.adapterKind === 'custom' ? assetStorage.module : undefined,
+    assetStorage.provider === 'custom' ? assetStorage.module : undefined,
     email.provider === 'custom' ? email.module : undefined,
     ...resolveAiFromConfig(handoff.config).connections.map((connection) => connection.module),
   ];
@@ -667,7 +667,7 @@ const copyCustomServerModules = async (handoff: Handoff, tracingRoot: string, en
     }
     if ([...fileList].some((file) => file.split(path.sep).join('/').endsWith('node_modules/handoff-app/dist/index.js'))) {
       throw new HandoffBuildError(
-        `The custom server module "${module}" imports "handoff-app", which loads the whole CLI. Import the define helpers from "handoff-app/define".`
+        `The custom server module "${module}" imports "handoff-app", which loads the whole CLI. Import the define helpers from "handoff-app/providers".`
       );
     }
     fileList.forEach((file) => files.add(file));

package/src/app-builder/client-config.ts

@@ -64,7 +64,7 @@ const buildServerRuntimeConfig = (config: ResolvedConfig, modeOverride?: Runtime
       databaseUrlEnv: resolveDatabaseUrlEnv(config),
     },
     assetStorage: {
-      adapter: assetStorage.adapterKind,
+      provider: assetStorage.provider,
       module: assetStorage.module,
       maxInlineBytes: assetStorage.maxInlineBytes,
       options: assetStorage.options,

package/src/config/loader.ts

@@ -5,7 +5,6 @@ import mergeWith from 'lodash/mergeWith';
 import omit from 'lodash/omit';
 import { createRequire } from 'module';
 import path from 'path';
-import { DEFAULT_EMAIL_PROVIDER } from '../registry/email/resolve';
 import { Config, HandoffEmailConfig, ResolvedConfig } from '../types/config';
 import { Logger } from '../utils/logger';
 import { resolveWorkingPath } from '../utils/path';
@@ -240,7 +239,7 @@ const replaceValues = (destination: unknown, source: unknown) => {
  * the deep merge never mixes the settings of two providers.
  */
 const resetEmailOnProviderChange = (layers: Partial<Config>[]): Partial<Config>[] => {
-  let provider: string = DEFAULT_EMAIL_PROVIDER;
+  let provider: string | undefined;
   let start = 0;
   layers.forEach((layer, index) => {
     const next = layer.runtime?.registry?.email?.provider;

package/src/index.ts

@@ -697,13 +697,13 @@ export type {
   SourceFormat,
   RendererKind,
 } from './catalog';
-export { defineAssetStorage } from './registry/asset-storage/define';
+export { defineStorageProvider } from './registry/asset-storage/define';
 export type {
-  AssetStorage,
-  AssetStorageContext,
-  AssetStorageFactory,
-  AssetStorageInput,
-  AssetStorageReadResult,
+  StorageProvider,
+  StorageProviderContext,
+  StorageProviderFactory,
+  StorageInput,
+  StorageReadResult,
   AssetUpload,
   AssetUploadInput,
 } from './registry/asset-storage/types';

package/src/nav/index.ts

@@ -89,6 +89,6 @@ export interface NavData {
 export { getNavData } from './resolver';
 export type { GetNavDataInput } from './resolver';
 export { getWorkspaceNavData } from './workspace';
-export type { WorkspaceNavAdapterOptions, WorkspaceNavLoaders } from './workspace';
+export type { WorkspaceNavOptions, WorkspaceNavLoaders } from './workspace';
 export { getRegistryNavData } from './registry';
-export type { RegistryNavAdapterOptions, RegistryNavRecords } from './registry';
+export type { RegistryNavOptions, RegistryNavRecords } from './registry';

package/src/nav/registry.ts

@@ -9,7 +9,7 @@ export interface RegistryNavRecords {
   tokenSets: NavTokenSet[];
 }
 
-export interface RegistryNavAdapterOptions {
+export interface RegistryNavOptions {
   shell: SectionLink[];
   load: NavLoad;
   basePath?: string;
@@ -18,8 +18,8 @@ export interface RegistryNavAdapterOptions {
 
 const emptyRecords = (): RegistryNavRecords => ({ components: [], patterns: [], pages: [], tokenSets: [] });
 
-/** Registry adapter: shell-only initial load, or one best-effort runtime-record fetch on refresh. */
-export const getRegistryNavData = async (options: RegistryNavAdapterOptions): Promise<NavData> => {
+/** Registry nav data: shell-only initial load, or one best-effort runtime-record fetch on refresh. */
+export const getRegistryNavData = async (options: RegistryNavOptions): Promise<NavData> => {
   let records = emptyRecords();
   if (options.load === 'refresh') {
     try {

package/src/nav/workspace.ts

@@ -14,7 +14,7 @@ export interface WorkspaceNavLoaders {
   tokenSets: () => Awaitable<NavTokenSet[]>;
 }
 
-export interface WorkspaceNavAdapterOptions {
+export interface WorkspaceNavOptions {
   docRoot: string;
   workingPagesDir?: string;
   basePath?: string;
@@ -43,8 +43,8 @@ const markdownTitle = (id: string, docRoot: string, workingPagesDir?: string): s
   return undefined;
 };
 
-/** Workspace/static adapter: live filesystem shell plus best-effort local snapshot loaders. */
-export const getWorkspaceNavData = async (options: WorkspaceNavAdapterOptions): Promise<NavData> => {
+/** Workspace/static nav data: live filesystem shell plus best-effort local snapshot loaders. */
+export const getWorkspaceNavData = async (options: WorkspaceNavOptions): Promise<NavData> => {
   const [loadedComponents, patterns, pages, loadedTokenSets] = await Promise.all([
     safeLoad(options.loaders.components),
     safeLoad(options.loaders.patterns),

package/src/{define.ts → providers.ts}

@@ -1,16 +1,16 @@
 /**
- * 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.
+ * Define helpers for custom server modules: storage, email and AI providers. 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 { defineStorageProvider } from './registry/asset-storage/define';
 export type {
-  AssetStorage,
-  AssetStorageContext,
-  AssetStorageFactory,
-  AssetStorageInput,
-  AssetStorageReadResult,
+  StorageProvider,
+  StorageProviderContext,
+  StorageProviderFactory,
+  StorageInput,
+  StorageReadResult,
   AssetUpload,
   AssetUploadInput,
 } from './registry/asset-storage/types';

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

@@ -1,15 +1,15 @@
 /**
- * Typed identity helper for custom asset storage adapters (mirrors `defineCatalogItem`): a consumer
+ * Typed identity helper for custom asset storage providers (mirrors `defineCatalogItem`): a consumer
  * default-exports its result from a **server-only** module and points
  * `runtime.registry.assetStorage.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 adapter object, or a factory `(context) => AssetStorage` when it needs its options/env.
+ * may be the provider object, or a factory `(context) => StorageProvider` when it needs its options/env.
  */
 
-import type { AssetStorage, AssetStorageFactory } from './types';
+import type { StorageProvider, StorageProviderFactory } from './types';
 
-export function defineAssetStorage(adapter: AssetStorage): AssetStorage;
-export function defineAssetStorage(factory: AssetStorageFactory): AssetStorageFactory;
-export function defineAssetStorage(input: AssetStorage | AssetStorageFactory): AssetStorage | AssetStorageFactory {
+export function defineStorageProvider(provider: StorageProvider): StorageProvider;
+export function defineStorageProvider(factory: StorageProviderFactory): StorageProviderFactory;
+export function defineStorageProvider(input: StorageProvider | StorageProviderFactory): StorageProvider | StorageProviderFactory {
   return input;
 }

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

@@ -2,54 +2,50 @@
  * Asset storage settings resolution.
  *
  * `runtime.registry.assetStorage` selects the active provider for **new** uploads: the built-in
- * `database` inline default or a `custom` module. The build bakes the adapter, the module location,
+ * `database` inline default 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, before the custom adapter factory runs.
+ * and is resolved at request time, before the custom provider factory runs.
  */
 
 import { HandoffConfigError } from '../../config/errors';
 import type { ResolvedConfig } from '../../types/config';
 import type { AssetStorageProvider } from '../db/schema';
 
-/** Which adapter implementation is active. Recorded on each blob row as its storage provider. */
-export type AssetStorageAdapterKind = AssetStorageProvider;
-
 /** The raw, authored settings block (a structural copy of the config type, resolvable from bake). */
 export interface AssetStorageSettings {
-  adapter?: AssetStorageAdapterKind;
+  provider?: AssetStorageProvider;
   module?: string;
   maxInlineBytes?: number;
   options?: Record<string, unknown>;
 }
 
-const ADAPTERS: readonly AssetStorageAdapterKind[] = ['database', 'custom'];
+const PROVIDERS: readonly AssetStorageProvider[] = ['database', 'custom'];
 
-/** Default adapter when none is configured. */
-export const DEFAULT_ASSET_STORAGE_ADAPTER: AssetStorageAdapterKind = 'database';
+export const DEFAULT_ASSET_STORAGE_PROVIDER: AssetStorageProvider = 'database';
 
 /** Default max bytes kept inline in Postgres `bytea` (4 MB, under Vercel's ~4.5 MB function limit). */
 export const DEFAULT_MAX_INLINE_BYTES = 4 * 1024 * 1024;
 
 /** Fully resolved asset storage settings. */
 export interface ResolvedAssetStorage {
-  /** The active adapter implementation. */
-  adapterKind: AssetStorageAdapterKind;
-  /** For `custom`: the server-only adapter module path. */
+  /** Recorded on each new blob row as its storage provider. */
+  provider: AssetStorageProvider;
+  /** For `custom`: the server-only provider module path. */
   module?: string;
   /** For `database`: the inline-content size ceiling. */
   maxInlineBytes: number;
-  /** Adapter options: literals and `{ $env }` references, never secret values. */
+  /** Provider options: literals and `{ $env }` references, never secret values. */
   options: Record<string, unknown>;
 }
 
 /** Resolve raw asset storage settings into a fully-defaulted shape. */
 export const resolveAssetStorageSettings = (settings: AssetStorageSettings | null | undefined): ResolvedAssetStorage => {
-  const adapterKind = settings?.adapter ?? DEFAULT_ASSET_STORAGE_ADAPTER;
+  const provider = settings?.provider ?? DEFAULT_ASSET_STORAGE_PROVIDER;
   const options = settings?.options ?? {};
   const maxInlineBytes =
     typeof settings?.maxInlineBytes === 'number' && settings.maxInlineBytes > 0 ? settings.maxInlineBytes : DEFAULT_MAX_INLINE_BYTES;
 
-  return { adapterKind, module: settings?.module?.trim() || undefined, maxInlineBytes, options };
+  return { provider, module: settings?.module?.trim() || undefined, maxInlineBytes, options };
 };
 
 /** Resolve and validate the asset storage block from a loaded config (CLI/build side). An unusable block fails the build. */
@@ -59,17 +55,17 @@ export const resolveAssetStorageFromConfig = (config: ResolvedConfig | null | un
     throw new HandoffConfigError(`Config "runtime.registry.assetStorage": ${problem}`);
   };
 
-  const adapter = settings?.adapter ?? DEFAULT_ASSET_STORAGE_ADAPTER;
-  if (!ADAPTERS.includes(adapter as AssetStorageAdapterKind)) {
-    fail(`unknown adapter ${JSON.stringify(adapter)}. Use "database" or "custom".`);
+  const provider = settings?.provider ?? DEFAULT_ASSET_STORAGE_PROVIDER;
+  if (!PROVIDERS.includes(provider as AssetStorageProvider)) {
+    fail(`unknown provider ${JSON.stringify(provider)}. Use "database" or "custom".`);
   }
   const options = settings?.options;
   if (options !== undefined && (options === null || typeof options !== 'object' || Array.isArray(options))) {
     fail('"options" must be an object.');
   }
   const module = settings?.module;
-  if (adapter === 'custom' && (typeof module !== 'string' || !module.trim())) {
-    fail('adapter "custom" needs a "module" that default-exports a defineAssetStorage() result.');
+  if (provider === 'custom' && (typeof module !== 'string' || !module.trim())) {
+    fail('provider "custom" needs a "module" that default-exports a defineStorageProvider() result.');
   }
   const maxInlineBytes = settings?.maxInlineBytes;
   if (maxInlineBytes !== undefined && (typeof maxInlineBytes !== 'number' || !Number.isInteger(maxInlineBytes) || maxInlineBytes <= 0)) {

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 };
     }