@netlify/spark-ui 1.30.0 → 1.31.0-alpha.1

package/packages/components/preact/DropZone/drop-core/errors.ts

@@ -12,6 +12,67 @@ export class UnsupportedDropError extends Error {
   }
 }
 
+/**
+ * Thrown when an authenticated path (static or build) turns out to have no
+ * usable session — the short-lived upload token came back empty, or the
+ * session-cookie site create was refused, so nothing was created. For static
+ * drops the flow falls back to the anonymous drop + claim; builds have no
+ * anonymous equivalent, so the consumer's only recourse is to send the visitor
+ * through login/signup and have them drop again.
+ */
+export class NotAuthenticatedError extends Error {
+  constructor(message = 'not authenticated') {
+    super(message);
+    this.name = 'NotAuthenticatedError';
+  }
+}
+
+/** `POST …/sites` failed, so there is nothing to build into. Carries the HTTP status. */
+export class SiteCreateError extends Error {
+  status?: number;
+
+  constructor(status?: number) {
+    super(`site create failed${status ? `: ${status}` : ''}`);
+    this.name = 'SiteCreateError';
+    this.status = status;
+  }
+}
+
+/**
+ * The multipart `POST /sites/{id}/builds` upload itself failed — the build never
+ * started. Distinct from `BuildFailedError`, which is a build that ran and broke.
+ */
+export class BuildCreateError extends Error {
+  status?: number;
+
+  constructor(status?: number) {
+    super(`build create failed${status ? `: ${status}` : ''}`);
+    this.name = 'BuildCreateError';
+    this.status = status;
+  }
+}
+
+/**
+ * The build ran and ended in `error`/`rejected`. `reason` is the API's
+ * `error_message` when there is one — it's the only part of a build failure that
+ * says anything actionable (a failing build command, a missing dependency), so
+ * it is surfaced to the user rather than swallowed.
+ */
+export class BuildFailedError extends Error {
+  constructor(public reason?: string) {
+    super(reason ? `build failed: ${reason}` : 'build failed');
+    this.name = 'BuildFailedError';
+  }
+}
+
+/** The build hadn't settled before the poller gave up. The build itself may still finish. */
+export class BuildTimeoutError extends Error {
+  constructor() {
+    super('Build did not finish in time');
+    this.name = 'BuildTimeoutError';
+  }
+}
+
 /**
  * Turn a raw deploy failure into copy a non-technical user can act on.
  * The original message is still tracked via analytics — this is only for display.
@@ -23,6 +84,26 @@ export function humanizeDropError(err: unknown): string {
     return 'To deploy, drop a folder or a .zip file — or a single HTML page.';
   }
 
+  if (err instanceof NotAuthenticatedError) {
+    return 'Please log in to Netlify to deploy a project that needs a build, then try again.';
+  }
+
+  if (err instanceof SiteCreateError) {
+    return "We couldn't create a project for this build. Please try again.";
+  }
+
+  // The build's own error message is the only actionable part of a build
+  // failure, so pass it straight through instead of a generic apology.
+  if (err instanceof BuildFailedError) {
+    return err.reason
+      ? `Your build failed: ${err.reason}`
+      : 'Your build failed. Check your build settings and try again.';
+  }
+
+  if (err instanceof BuildTimeoutError) {
+    return 'Your build is taking longer than expected. It may still finish — check your Netlify dashboard.';
+  }
+
   if (err.message === 'Deploy did not become ready in time') {
     return 'Your site is taking longer than expected to go live. Please try again in a moment.';
   }
@@ -31,7 +112,9 @@ export function humanizeDropError(err: unknown): string {
     return "Couldn't connect to Netlify. Check your internet connection and try again.";
   }
 
-  // client.ts attaches `.status` to API failures — see apiError().
+  // client.ts attaches `.status` to API failures (see apiError()), as do the
+  // typed build errors above — so `BuildCreateError(413)` lands on the
+  // upload-too-large copy rather than a generic message.
   const status = 'status' in err && typeof err.status === 'number' ? err.status : undefined;
 
   switch (status) {

package/packages/components/preact/DropZone/drop-core/index.ts

@@ -4,5 +4,8 @@ export * from './readFiles';
 export * from './fileTypes';
 export * from './detectBuild';
 export * from './client';
+export * from './authedDropClient';
+export * from './buildClient';
+export * from './zip';
 export * from './deploy';
 export * from './errors';

package/packages/components/preact/DropZone/drop-core/readFiles.ts

@@ -123,7 +123,7 @@ async function readZip(zip: File): Promise<ProcessedFile[]> {
     // ArrayBuffer, so narrow it for toProcessedFile's ArrayBuffer parameter.
     const content = bytes.buffer.slice(
       bytes.byteOffset,
-      bytes.byteOffset + bytes.byteLength,
+      bytes.byteOffset + bytes.byteLength
     ) as ArrayBuffer;
     out.push(toProcessedFile(path, content, path.split('/').pop()!));
   }

package/packages/components/preact/DropZone/drop-core/types.ts

@@ -34,7 +34,18 @@ export interface DeployResult {
   url: string; // https://<subdomain>.netlify.app
 }
 
-export type DeployPhase = 'creating' | 'uploading' | 'processing' | 'ready';
+/**
+ * Phases shared by both deploy paths. A static drop runs
+ * creating → uploading → processing → ready; a build drop runs
+ * zipping → creating → uploading → building → ready.
+ */
+export type DeployPhase =
+  | 'zipping'
+  | 'creating'
+  | 'uploading'
+  | 'processing'
+  | 'building'
+  | 'ready';
 
 export interface DeployProgress {
   phase: DeployPhase;

package/packages/components/preact/DropZone/drop-core/zip.ts

@@ -0,0 +1,118 @@
+import { inferBuildSettings, type InferredBuildSettings } from './detectBuild';
+import type { ProcessedFile } from './types';
+
+const NETLIFY_TOML_PATH = '/netlify.toml';
+
+/** TOML basic-string escaping — enough for the two values we ever write. */
+function escapeTomlString(value: string): string {
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t');
+}
+
+/**
+ * Render inferred settings as a `[build]` table. Only `command` and `publish`
+ * are written: everything else (functions directory, plugins, node version)
+ * is zero-config on Netlify's side and guessing at it would override detection
+ * that is better informed than we are.
+ */
+export function generateNetlifyToml({ command, publish }: InferredBuildSettings): string {
+  return [
+    '[build]',
+    `  command = "${escapeTomlString(command)}"`,
+    `  publish = "${escapeTomlString(publish)}"`,
+    '',
+  ].join('\n');
+}
+
+export interface ZipOptions {
+  /** Filename given to the produced `File`. Shows up as the build's source archive. */
+  name?: string;
+  /**
+   * Synthesise a `netlify.toml` `[build]` table from `inferBuildSettings` when the
+   * drop doesn't declare one (default `true`). Set `false` to upload the files
+   * exactly as dropped and let buildbot resolve every setting itself.
+   */
+  synthesizeNetlifyToml?: boolean;
+}
+
+export interface ZipResult {
+  /** The archive, ready to hand to `createBuildFromZip`. */
+  file: File;
+  /**
+   * The settings written into `netlify.toml`, or `null` when the archive is a
+   * faithful copy of the drop — either because it already declared a `[build]`
+   * table, or because nothing could be inferred with confidence.
+   */
+  buildSettings: InferredBuildSettings | null;
+}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+function toBytes(content: ArrayBuffer): Uint8Array {
+  return new Uint8Array(content);
+}
+
+/**
+ * Zip an already-read file set into the source archive that
+ * `POST /sites/{id}/builds` expects.
+ *
+ * The input is the same root-normalized `ProcessedFile[]` the static deploy path
+ * uses (see `readFiles`), so junk — dotfiles, `node_modules`, macOS metadata — is
+ * already gone and paths sit at the deploy root. Output directories (`dist/`,
+ * `build/`) are deliberately *not* stripped: buildbot regenerates them when
+ * there's a build command, and a drop whose `netlify.toml` publishes a committed
+ * directory without a command would break if we removed it.
+ *
+ * When the drop needs a build but declares no `[build]` table, an inferred one is
+ * written in (appended to an existing `netlify.toml`, or created if there is
+ * none) so buildbot doesn't publish the project's source. See
+ * `inferBuildSettings` for how conservative that inference is.
+ */
+export async function zipFiles(
+  files: ProcessedFile[],
+  { name = 'source.zip', synthesizeNetlifyToml = true }: ZipOptions = {}
+): Promise<ZipResult> {
+  if (!files.length) throw new Error('No files to deploy');
+
+  const buildSettings = synthesizeNetlifyToml ? inferBuildSettings(files) : null;
+
+  const entries: Record<string, Uint8Array> = {};
+  for (const file of files) {
+    // fflate keys are paths relative to the archive root, so drop the leading
+    // slash `ProcessedFile.path` carries.
+    const path = file.path.replace(/^\//, '');
+    if (path) entries[path] = toBytes(file.content);
+  }
+
+  if (buildSettings) {
+    const existing = files.find(f => f.path === NETLIFY_TOML_PATH);
+    const table = generateNetlifyToml(buildSettings);
+    // Append rather than replace so the drop's own redirects, headers and
+    // environment survive alongside the synthesised build settings.
+    const contents = existing
+      ? `${decoder.decode(existing.content).replace(/\n*$/, '\n')}\n${table}`
+      : table;
+    entries['netlify.toml'] = encoder.encode(contents);
+  }
+
+  // fflate is loaded on demand — same as the unzip path in readFiles — so a
+  // consumer that never drops a build project never pays for it.
+  const { zip } = await import('fflate');
+  const bytes = await new Promise<Uint8Array>((resolve, reject) =>
+    zip(entries, { level: 6 }, (err, out) => (err ? reject(err) : resolve(out)))
+  );
+
+  // `bytes.buffer` is ArrayBufferLike; narrow it to the plain ArrayBuffer the
+  // File constructor takes, the same way readFiles does on the unzip side.
+  const archive = bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  ) as ArrayBuffer;
+  const file = new File([archive], name, { type: 'application/zip' });
+  return { file, buildSettings };
+}

package/packages/components/preact/DropZone/index.tsx

@@ -1,20 +1,43 @@
 export { default as DropZone } from './DropZone';
 export {
   AnonymousDropClient,
+  AuthenticatedBuildClient,
+  AuthenticatedDropClient,
+  BuildCreateError,
+  BuildFailedError,
+  BuildTimeoutError,
+  deployBuild,
   deployFiles,
   detectBuild,
   getFileTypes,
+  humanizeDropError,
+  inferBuildSettings,
+  NotAuthenticatedError,
   readDataTransfer,
   readFileList,
+  SiteCreateError,
+  UnsupportedDropError,
+  zipFiles,
 } from './drop-core';
 export type {
+  AuthenticatedBuildClientConfig,
+  AuthenticatedDropClientConfig,
+  BuildClient,
+  BuildDeployOptions,
+  BuildDeployResult,
   BuildDetection,
   BuildReason,
+  BuildResponse,
+  BuildSite,
   DropClient,
   DropResponse,
   Digest,
   DeployResult,
   DeployProgress,
   DeployPhase,
+  InferredBuildSettings,
   ProcessedFile,
+  ZipOptions,
+  ZipResult,
 } from './drop-core';
+export type { DeployedBuild, DeployedSite, DeployError, DeployStatus } from './useDropDeploy';

package/packages/components/preact/DropZone/useDropDeploy.ts

@@ -1,15 +1,22 @@
 import { useRef, useState } from 'preact/hooks';
 import {
   AnonymousDropClient,
+  AuthenticatedBuildClient,
+  AuthenticatedDropClient,
+  deployBuild,
   deployFiles,
   detectBuild,
   getSingleNonIndexHtmlFileName,
   hasMultipleHtmlFilesWithoutIndex,
   humanizeDropError,
+  NotAuthenticatedError,
   renameSingleNonIndexHtmlToIndex,
+  type BuildClient,
   type BuildDetection,
   type DeployProgress,
+  type DeployResult,
   type DropClient,
+  type InferredBuildSettings,
   type ProcessedFile,
 } from './drop-core';
 
@@ -19,9 +26,15 @@ export type DeploySource = 'drag' | 'browse';
 /** The live site handed back once a deploy succeeds. */
 export interface DeployedSite {
   url: string;
-  token: string;
+  /**
+   * Drop claim token — only present for anonymous deploys. An authenticated
+   * deploy lands directly in the visitor's account, so there is nothing to claim.
+   */
+  token?: string;
   siteName: string;
   siteId: string;
+  /** True when the deploy landed directly in the visitor's account. */
+  authenticated: boolean;
 }
 
 /** A deploy failure, handed to `onError` so consumers can render their own error UI. */
@@ -32,16 +45,36 @@ export interface DeployError {
   reason: string;
 }
 
+/** The build handed back once a build-required drop is enqueued. */
+export interface DeployedBuild {
+  /** The site created for the build — live once the build finishes. */
+  url: string;
+  siteName: string;
+  siteId: string;
+  buildId: string;
+  /** The deploy the build produces, if the API has assigned one yet. */
+  deployId?: string;
+  /** Build settings synthesised into the uploaded `netlify.toml`, if any. */
+  buildSettings: InferredBuildSettings | null;
+}
+
 /** Finite states of a single deploy attempt. */
 export type DeployStatus =
   | { kind: 'idle' }
   | { kind: 'reading' }
+  // Build path only: packing the drop into the source archive buildbot builds.
+  | { kind: 'zipping' }
   | { kind: 'creating' }
   | { kind: 'uploading'; uploaded: number; total: number }
   | { kind: 'processing' }
-  // `claim` follows a static deploy (hand off to the claim page); `signup`
-  // follows a build-required drop (hand off to the authenticated Drop page).
-  | { kind: 'redirecting'; target: 'claim' | 'signup' }
+  // Build path only: the archive is uploaded and buildbot is building it.
+  | { kind: 'building' }
+  // `claim` follows an anonymous static deploy (hand off to the claim page);
+  // `dashboard` follows an authenticated static deploy (hand off to the new
+  // site's project page); `build` follows an authenticated build (hand off to
+  // the app's project page while the build runs); `signup` follows a
+  // build-required drop with no session to build it with.
+  | { kind: 'redirecting'; target: 'claim' | 'dashboard' | 'signup' | 'build' }
   | { kind: 'error'; message: string };
 
 /** Provider-agnostic analytics sink. */
@@ -51,9 +84,18 @@ interface UseDropDeployOptions {
   apiBase?: string;
   client?: DropClient;
   claimUrl: (siteName: string) => string;
+  siteDashboardUrl: (siteName: string) => string;
   buildSignupUrl: string;
+  buildClient?: BuildClient;
+  authenticatedDropClient?: DropClient;
+  getUploadToken?: () => Promise<string | null>;
+  proxyBase?: string;
+  accountSlug?: string;
+  buildDeployUrl: (build: DeployedBuild) => string;
+  waitForBuild?: boolean;
   onBuildRequired?: (info: BuildDetection) => void;
   onDeploy?: (site: DeployedSite) => void;
+  onBuildDeploy?: (build: DeployedBuild) => void;
   onError?: (error: DeployError) => void;
   track: TrackFn;
 }
@@ -61,10 +103,14 @@ interface UseDropDeployOptions {
 /** Map a low-level deploy progress event onto our UI status. */
 function progressToStatus(e: DeployProgress): DeployStatus {
   switch (e.phase) {
+    case 'zipping':
+      return { kind: 'zipping' };
     case 'creating':
       return { kind: 'creating' };
     case 'uploading':
       return { kind: 'uploading', uploaded: e.uploaded ?? 0, total: e.total ?? 0 };
+    case 'building':
+      return { kind: 'building' };
     case 'processing':
     case 'ready':
       return { kind: 'processing' };
@@ -91,9 +137,18 @@ export function useDropDeploy({
   apiBase,
   client,
   claimUrl,
+  siteDashboardUrl,
   buildSignupUrl,
+  buildClient,
+  authenticatedDropClient,
+  getUploadToken,
+  proxyBase,
+  accountSlug,
+  buildDeployUrl,
+  waitForBuild,
   onBuildRequired,
   onDeploy,
+  onBuildDeploy,
   onError,
   track,
 }: UseDropDeployOptions) {
@@ -101,8 +156,58 @@ export function useDropDeploy({
   const [warning, setWarning] = useState<string | null>(null);
   const dropClient = useRef(client ?? new AnonymousDropClient(apiBase)).current;
 
+  // Building is opt-in: without an injected client or a way to mint an upload
+  // token there is no authenticated path, and build-required drops fall back to
+  // the signup hand-off. Built once and held so a re-render doesn't hand a
+  // fresh client (and a fresh token cache) to an in-flight deploy.
+  const authedBuildClient = useRef(
+    buildClient ??
+      (getUploadToken
+        ? new AuthenticatedBuildClient({ proxyBase, getUploadToken, accountSlug })
+        : null)
+  ).current;
+
+  // Same opt-in for static drops: with authenticated wiring present, deploy
+  // straight into the visitor's account and skip the claim step; without it,
+  // every static drop stays anonymous.
+  const authedDropClient = useRef(
+    authenticatedDropClient ??
+      (getUploadToken
+        ? new AuthenticatedDropClient({ proxyBase, getUploadToken, accountSlug })
+        : null)
+  ).current;
+
   const busy = status.kind !== 'idle' && status.kind !== 'error';
 
+  /**
+   * Zip the drop, create a site and enqueue a build. Returns `null` when the
+   * visitor turns out not to be logged in — nothing is created in that case, so
+   * the caller can still fall back to the signup hand-off. Every other failure
+   * throws and is reported by the caller's `catch`.
+   */
+  async function buildProject(
+    client: BuildClient,
+    files: ProcessedFile[]
+  ): Promise<DeployedBuild | null> {
+    try {
+      const { site, build, buildSettings, url } = await deployBuild(client, files, {
+        onProgress: e => setStatus(progressToStatus(e)),
+        waitForBuild,
+      });
+      return {
+        url,
+        siteName: site.name,
+        siteId: site.id,
+        buildId: build.id,
+        deployId: build.deploy_id,
+        buildSettings,
+      };
+    } catch (err) {
+      if (err instanceof NotAuthenticatedError) return null;
+      throw err;
+    }
+  }
+
   /**
    * `fileTypes` is the MIME types of the selection, read at the drop boundary
    * (see `getFileTypes`) and passed in rather than derived here — it has to be
@@ -164,9 +269,10 @@ export function useDropDeploy({
 
       // Build-required projects can't deploy through the anonymous drop API —
       // it only performs static deploys, so building one this way yields a
-      // broken site. Detect them up front and hand off to the authenticated
-      // Drop page (via signup) instead. Consumers can override the hand-off
-      // with `onBuildRequired`.
+      // broken site. Detect them up front and route them to the build path
+      // (which needs a logged-in user) or, failing that, hand off to the
+      // authenticated Drop page via signup. Consumers can override the hand-off
+      // entirely with `onBuildRequired`.
       const build = detectBuild(files);
       if (build.buildRequired) {
         track('dropzone_build_required', {
@@ -182,6 +288,26 @@ export function useDropDeploy({
           onBuildRequired(build);
           return;
         }
+        if (authedBuildClient) {
+          const built = await buildProject(authedBuildClient, files);
+          // No session after all (the auth hint cookie can outlive the session).
+          // Nothing was created, so fall through to the signup hand-off rather
+          // than dead-ending on an error the visitor can't act on from here.
+          if (built) {
+            setStatus({ kind: 'redirecting', target: 'build' });
+            track('dropzone_build_deploy_succeeded', {
+              method: source,
+              reason: build.reason,
+              site_name: built.siteName,
+              file_count: files.length,
+              ...(built.buildSettings ? { framework: built.buildSettings.framework } : {}),
+              ...typeProps,
+            });
+            onBuildDeploy?.(built);
+            window.location.assign(buildDeployUrl(built));
+            return;
+          }
+        }
         setStatus({ kind: 'redirecting', target: 'signup' });
         window.location.assign(buildSignupUrl);
         return;
@@ -189,41 +315,80 @@ export function useDropDeploy({
 
       setWarning(indexHtmlWarning(files));
 
-      const {
-        url,
-        token,
-        deploy: result,
-      } = await deployFiles(dropClient, files, {
-        onProgress: e => setStatus(progressToStatus(e)),
-      });
+      // Deploy into the visitor's account when we can. NotAuthenticatedError is
+      // the one failure that falls back to the anonymous flow — it's thrown
+      // before anything is created (the auth hint cookie can outlive the
+      // session), so retrying anonymously can't strand a half-made site. Any
+      // later failure is real and surfaces as an error instead: falling back
+      // then would leave an empty site in the account and deploy a duplicate.
+      let deployed: DeployResult | null = null;
+      let authenticated = false;
+      let authFallback = false;
+      if (authedDropClient) {
+        try {
+          deployed = await deployFiles(authedDropClient, files, {
+            onProgress: e => setStatus(progressToStatus(e)),
+          });
+          authenticated = true;
+        } catch (err) {
+          if (!(err instanceof NotAuthenticatedError)) throw err;
+          authFallback = true;
+        }
+      }
+      if (!deployed) {
+        deployed = await deployFiles(dropClient, files, {
+          onProgress: e => setStatus(progressToStatus(e)),
+        });
+      }
+      const { url, token, deploy: result } = deployed;
 
-      // Best-effort local persistence. Note this does NOT reach the dashboard:
-      // localStorage is per-origin, so a token written here (e.g. www.netlify.com)
-      // is invisible to app.netlify.com. The cross-origin handoff is the URL
-      // fragment below; this only helps if the drop and claim share an origin.
-      try {
-        localStorage.setItem('drop-token', token);
-        localStorage.setItem('dropSiteName', result.subdomain);
-      } catch {
-        /* private mode / storage disabled — non-fatal */
+      if (!authenticated) {
+        // Best-effort local persistence. Note this does NOT reach the dashboard:
+        // localStorage is per-origin, so a token written here (e.g. www.netlify.com)
+        // is invisible to app.netlify.com. The cross-origin handoff is the URL
+        // fragment below; this only helps if the drop and claim share an origin.
+        // Authenticated deploys skip this entirely — there is no claim token,
+        // and the upload bearer must never be persisted.
+        try {
+          localStorage.setItem('drop-token', token);
+          localStorage.setItem('dropSiteName', result.subdomain);
+        } catch {
+          /* private mode / storage disabled — non-fatal */
+        }
       }
 
-      setStatus({ kind: 'redirecting', target: 'claim' });
+      setStatus({ kind: 'redirecting', target: authenticated ? 'dashboard' : 'claim' });
       // Fired before the redirect below. Note: the navigation can cut a
       // fire-and-forget analytics request short — see the docs for delivery
-      // hardening (sendBeacon / deferring the redirect).
+      // hardening (sendBeacon / deferring the redirect). `auth_fallback` is only
+      // sent when an authenticated attempt bounced (stale auth hint) — omitted
+      // otherwise, like `file_types`.
       track('dropzone_deploy_succeeded', {
         method: source,
         site_name: result.subdomain,
         file_count: files.length,
+        authenticated,
+        ...(authFallback ? { auth_fallback: true } : {}),
         ...typeProps,
       });
-      onDeploy?.({ url, token, siteName: result.subdomain, siteId: result.id });
+      onDeploy?.({
+        url,
+        ...(authenticated ? {} : { token }),
+        siteName: result.subdomain,
+        siteId: result.id,
+        authenticated,
+      });
 
-      // Hand the drop token to the dashboard via the URL fragment — localStorage
-      // does not cross origins. The dashboard's /drop/:name page reads
-      // `#drop_token=` and persists it for the claim + post-signup steps.
-      window.location.assign(`${claimUrl(result.subdomain)}#drop_token=${token}`);
+      if (authenticated) {
+        // The site already lives in the visitor's account — send them straight
+        // to its dashboard page. No claim step, no token in the URL.
+        window.location.assign(siteDashboardUrl(result.subdomain));
+      } else {
+        // Hand the drop token to the dashboard via the URL fragment — localStorage
+        // does not cross origins. The dashboard's /drop/:name page reads
+        // `#drop_token=` and persists it for the claim + post-signup steps.
+        window.location.assign(`${claimUrl(result.subdomain)}#drop_token=${token}`);
+      }
     } catch (err) {
       failFromError(err);
     }

package/packages/components/preact/index.ts

@@ -6,6 +6,7 @@ export { default as SearchHeading } from './SearchModal/components/SearchHeading
 export { default as SearchToggle } from './SearchModal/components/SearchToggle/SearchToggle';
 export { default as AskNetlify } from './AskNetlify/AskNetlify';
 export { SearchModal } from './SearchModal';
-export { DropZone } from './DropZone';
+export { DropZone, AuthenticatedBuildClient, AuthenticatedDropClient } from './DropZone';
+export type { BuildClient, DeployedBuild, DeployedSite, DropClient } from './DropZone';
 
 export { type IconName } from './Icon';