handoff-app 2.0.0-12 → 2.0.0-13

package/dist/registry/asset-storage/define.js

@@ -1,13 +1,13 @@
 "use strict";
 /**
- * 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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineAssetStorage = defineAssetStorage;
-function defineAssetStorage(input) {
+exports.defineStorageProvider = defineStorageProvider;
+function defineStorageProvider(input) {
     return input;
 }

package/dist/registry/asset-storage/resolve.d.ts

@@ -2,34 +2,31 @@
  * 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 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>;
 }
-/** Default adapter when none is configured. */
-export declare const DEFAULT_ASSET_STORAGE_ADAPTER: AssetStorageAdapterKind;
+export declare const DEFAULT_ASSET_STORAGE_PROVIDER: AssetStorageProvider;
 /** Default max bytes kept inline in Postgres `bytea` (4 MB, under Vercel's ~4.5 MB function limit). */
 export declare const DEFAULT_MAX_INLINE_BYTES: number;
 /** 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. */

package/dist/registry/asset-storage/resolve.js

@@ -3,25 +3,24 @@
  * 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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveAssetStorageFromConfig = exports.resolveAssetStorageSettings = exports.DEFAULT_MAX_INLINE_BYTES = exports.DEFAULT_ASSET_STORAGE_ADAPTER = void 0;
+exports.resolveAssetStorageFromConfig = exports.resolveAssetStorageSettings = exports.DEFAULT_MAX_INLINE_BYTES = exports.DEFAULT_ASSET_STORAGE_PROVIDER = void 0;
 const errors_1 = require("../../config/errors");
-const ADAPTERS = ['database', 'custom'];
-/** Default adapter when none is configured. */
-exports.DEFAULT_ASSET_STORAGE_ADAPTER = 'database';
+const PROVIDERS = ['database', 'custom'];
+exports.DEFAULT_ASSET_STORAGE_PROVIDER = 'database';
 /** Default max bytes kept inline in Postgres `bytea` (4 MB, under Vercel's ~4.5 MB function limit). */
 exports.DEFAULT_MAX_INLINE_BYTES = 4 * 1024 * 1024;
 /** Resolve raw asset storage settings into a fully-defaulted shape. */
 const resolveAssetStorageSettings = (settings) => {
     var _a, _b, _c;
-    const adapterKind = (_a = settings === null || settings === void 0 ? void 0 : settings.adapter) !== null && _a !== void 0 ? _a : exports.DEFAULT_ASSET_STORAGE_ADAPTER;
+    const provider = (_a = settings === null || settings === void 0 ? void 0 : settings.provider) !== null && _a !== void 0 ? _a : exports.DEFAULT_ASSET_STORAGE_PROVIDER;
     const options = (_b = settings === null || settings === void 0 ? void 0 : settings.options) !== null && _b !== void 0 ? _b : {};
     const maxInlineBytes = typeof (settings === null || settings === void 0 ? void 0 : settings.maxInlineBytes) === 'number' && settings.maxInlineBytes > 0 ? settings.maxInlineBytes : exports.DEFAULT_MAX_INLINE_BYTES;
-    return { adapterKind, module: ((_c = settings === null || settings === void 0 ? void 0 : settings.module) === null || _c === void 0 ? void 0 : _c.trim()) || undefined, maxInlineBytes, options };
+    return { provider, module: ((_c = settings === null || settings === void 0 ? void 0 : settings.module) === null || _c === void 0 ? void 0 : _c.trim()) || undefined, maxInlineBytes, options };
 };
 exports.resolveAssetStorageSettings = resolveAssetStorageSettings;
 /** Resolve and validate the asset storage block from a loaded config (CLI/build side). An unusable block fails the build. */
@@ -31,17 +30,17 @@ const resolveAssetStorageFromConfig = (config) => {
     const fail = (problem) => {
         throw new errors_1.HandoffConfigError(`Config "runtime.registry.assetStorage": ${problem}`);
     };
-    const adapter = (_c = settings === null || settings === void 0 ? void 0 : settings.adapter) !== null && _c !== void 0 ? _c : exports.DEFAULT_ASSET_STORAGE_ADAPTER;
-    if (!ADAPTERS.includes(adapter)) {
-        fail(`unknown adapter ${JSON.stringify(adapter)}. Use "database" or "custom".`);
+    const provider = (_c = settings === null || settings === void 0 ? void 0 : settings.provider) !== null && _c !== void 0 ? _c : exports.DEFAULT_ASSET_STORAGE_PROVIDER;
+    if (!PROVIDERS.includes(provider)) {
+        fail(`unknown provider ${JSON.stringify(provider)}. Use "database" or "custom".`);
     }
     const options = settings === null || settings === void 0 ? void 0 : settings.options;
     if (options !== undefined && (options === null || typeof options !== 'object' || Array.isArray(options))) {
         fail('"options" must be an object.');
     }
     const module = settings === null || settings === void 0 ? void 0 : 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 === null || settings === void 0 ? void 0 : settings.maxInlineBytes;
     if (maxInlineBytes !== undefined && (typeof maxInlineBytes !== 'number' || !Number.isInteger(maxInlineBytes) || maxInlineBytes <= 0)) {

package/dist/registry/asset-storage/types.d.ts

@@ -1,12 +1,12 @@
 /**
- * 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;
@@ -17,7 +17,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;
@@ -43,10 +43,10 @@ export interface AssetUpload {
     /** The reference to persist on the blob's `asset_blobs` row after the upload. */
     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<{
+    put(input: StorageInput): Promise<{
         storageRef: string;
     }>;
     /**
@@ -56,16 +56,16 @@ 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/dist/registry/asset-storage/types.js

@@ -1,8 +1,8 @@
 "use strict";
 /**
- * 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.
  */

package/dist/registry/db/schema.d.ts

@@ -24,7 +24,7 @@
 import type { ArtifactBuildStatus, ArtifactKind, ArtifactOwnerKind, ArtifactReference } from '../../artifacts/types';
 import type { RegistryTextFileKind } from '../../store/types';
 import type { TokenSetKind } from '../tokens/sets';
-/** 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';
 /** Registry account role. Administrators may issue write-scoped credentials. */
@@ -2439,7 +2439,7 @@ export declare const assets: import("drizzle-orm/pg-core").PgTableWithColumns<{
 /**
  * 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 declare const assetBlobs: import("drizzle-orm/pg-core").PgTableWithColumns<{

package/dist/registry/db/schema.js

@@ -28,7 +28,7 @@ const drizzle_orm_1 = require("drizzle-orm");
 const pg_core_1 = require("drizzle-orm/pg-core");
 /**
  * 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 = (0, pg_core_1.customType)({
@@ -321,7 +321,7 @@ exports.assets = (0, pg_core_1.pgTable)('assets', {
 /**
  * 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.
  */
 exports.assetBlobs = (0, pg_core_1.pgTable)('asset_blobs', {

package/dist/registry/email/define.d.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/dist/registry/email/define.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * 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/dist/registry/email/resolve.d.ts

@@ -1,19 +1,18 @@
 /**
  * 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 type { ResolvedConfig } from '../../types/config';
-export type EmailProviderKind = 'resend' | 'smtp' | 'custom';
-export declare const DEFAULT_EMAIL_PROVIDER: EmailProviderKind;
-/** Default env-var name holding the Resend API key. */
-export declare const DEFAULT_RESEND_API_KEY_ENV = "RESEND_API_KEY";
+export type EmailProviderKind = 'smtp' | 'custom';
 /** 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>;

package/dist/registry/email/resolve.js

@@ -2,45 +2,46 @@
 /**
  * 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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseEmailSettings = exports.resolveEmailFromConfig = exports.DEFAULT_RESEND_API_KEY_ENV = exports.DEFAULT_EMAIL_PROVIDER = void 0;
+exports.parseEmailSettings = exports.resolveEmailFromConfig = void 0;
 const errors_1 = require("../../config/errors");
-exports.DEFAULT_EMAIL_PROVIDER = 'resend';
-/** Default env-var name holding the Resend API key. */
-exports.DEFAULT_RESEND_API_KEY_ENV = 'RESEND_API_KEY';
-const PROVIDERS = ['resend', 'smtp', 'custom'];
+const PROVIDERS = ['smtp', 'custom'];
 /** The options each built-in provider accepts. A custom provider accepts any. */
 const BUILT_IN_OPTIONS = {
-    resend: ['apiKey'],
     smtp: ['host', 'port', 'secure', 'user', 'password'],
 };
 const isPlainRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 /** Resolve and validate the email block from a loaded config (CLI/build side). An unusable block fails the build. */
 const resolveEmailFromConfig = (config) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
     const email = (_b = (_a = config === null || config === void 0 ? void 0 : config.runtime) === null || _a === void 0 ? void 0 : _a.registry) === null || _b === void 0 ? void 0 : _b.email;
     const fail = (problem) => {
         throw new errors_1.HandoffConfigError(`Config "runtime.registry.email": ${problem}`);
     };
-    const provider = ((_c = email === null || email === void 0 ? void 0 : email.provider) !== null && _c !== void 0 ? _c : exports.DEFAULT_EMAIL_PROVIDER);
+    if (email === undefined)
+        return { options: {} };
+    const provider = email.provider;
     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 === null || email === void 0 ? void 0 : email.options) !== undefined && !isPlainRecord(email.options)) {
+    if (email.options !== undefined && !isPlainRecord(email.options)) {
         fail('"options" must be an object.');
     }
-    const options = Object.assign({}, ((_d = email === null || email === void 0 ? void 0 : email.options) !== null && _d !== void 0 ? _d : {}));
-    const module = typeof (email === null || email === void 0 ? void 0 : email.module) === 'string' ? email.module.trim() : undefined;
+    const options = Object.assign({}, ((_c = email.options) !== null && _c !== void 0 ? _c : {}));
+    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 === null || email === void 0 ? void 0 : email.module) !== undefined)
+        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));
@@ -51,26 +52,23 @@ const resolveEmailFromConfig = (config) => {
     }
     if (provider === 'smtp' && options.host === undefined)
         fail('provider "smtp" needs "options.host".');
-    if (provider === 'resend' && options.apiKey === undefined)
-        options.apiKey = { $env: exports.DEFAULT_RESEND_API_KEY_ENV };
-    const from = typeof (email === null || email === void 0 ? void 0 : email.from) === 'string' ? email.from.trim() || undefined : undefined;
+    const from = typeof email.from === 'string' ? email.from.trim() || undefined : undefined;
     return Object.assign(Object.assign({ from, provider }, (module ? { module } : {})), { options });
 };
 exports.resolveEmailFromConfig = resolveEmailFromConfig;
 /** Read baked settings back leniently (server side): a malformed value must not take the server down. */
 const parseEmailSettings = (raw) => {
-    var _a;
     let options = raw.options;
     if (typeof options === 'string') {
         try {
             options = options.trim() ? JSON.parse(options) : {};
         }
-        catch (_b) {
+        catch (_a) {
             options = {};
         }
     }
-    const provider = (_a = PROVIDERS.find((kind) => kind === raw.provider)) !== null && _a !== void 0 ? _a : exports.DEFAULT_EMAIL_PROVIDER;
+    const provider = PROVIDERS.find((kind) => kind === raw.provider);
     const module = typeof raw.module === 'string' ? raw.module.trim() : '';
-    return Object.assign(Object.assign({ from: typeof raw.from === 'string' ? raw.from.trim() || undefined : undefined, provider }, (module ? { module } : {})), { options: isPlainRecord(options) ? options : {} });
+    return Object.assign(Object.assign(Object.assign({ from: typeof raw.from === 'string' ? raw.from.trim() || undefined : undefined }, (provider ? { provider } : {})), (module ? { module } : {})), { options: isPlainRecord(options) ? options : {} });
 };
 exports.parseEmailSettings = parseEmailSettings;

package/dist/registry/email/types.d.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. */
 export interface EmailMessage {

package/dist/registry/email/types.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
  * 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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/registry.d.ts

@@ -13,7 +13,7 @@
  * - Reads never materialize source files or run the build pipeline — every record and file is
  *   returned exactly as it was published.
  */
-import type { AssetStorage } from '../registry/asset-storage/types';
+import type { StorageProvider } from '../registry/asset-storage/types';
 import type { RegistryDatabase } from '../registry/db/client';
 import { type AssetStorageProvider } from '../registry/db/schema';
 import type { ComponentListObject, PageListObject, PatternListObject } from '../transformers/preview/types';
@@ -22,11 +22,11 @@ import type { AssetContentResource, AssetMetadata, AssetStore, ComponentStore, H
 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>;
 }
 export declare class RegistryComponentStore implements ComponentStore {
     private readonly context;

package/dist/store/registry.js

@@ -404,14 +404,14 @@ class RegistryAssetStore {
                 return Object.assign(Object.assign({}, base), { body: Buffer.from(row.blobContent) });
             }
             // 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 = yield this.context.resolveAssetAdapter(row.storageProvider);
-            if (!adapter) {
+            const storage = yield this.context.resolveStorageProvider(row.storageProvider);
+            if (!storage) {
                 return null;
             }
-            const result = yield adapter.get(row.storageRef);
+            const result = yield storage.get(row.storageRef);
             if (result.kind === 'redirect') {
                 return Object.assign(Object.assign({}, base), { redirectUrl: result.url });
             }

package/dist/types/config.d.ts

@@ -126,15 +126,6 @@ interface HandoffEmailBase {
     /** Sender address, such as `Handoff <no-reply@example.com>`. Use a profile for per-environment values. */
     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';
@@ -164,7 +155,7 @@ export interface HandoffCustomEmail extends HandoffEmailBase {
     options?: Record<string, unknown>;
 }
 /** 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
  * key for a declared connection and nothing else, so the server never calls a URL a reader chose.
@@ -268,13 +259,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>;