@netlify/spark-ui 1.31.0-alpha.3 → 1.31.0-alpha.5

package/packages/{components/preact/DropZone/drop-core → drop-core}/client.ts

@@ -1,3 +1,12 @@
+/**
+ * The `DropClient` seam: the four calls a static deploy needs — mint a token,
+ * create the deploy, upload a file, wait until ready — behind one interface,
+ * so `deployFiles` runs the same pipeline whether the deploy is anonymous
+ * (this file's `AnonymousDropClient`, claimed later by the visitor) or lands
+ * directly in an account (`authedDropClient.ts`).
+ */
+import { DEFAULT_API_BASE, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS } from './constants';
+import { DeployTimeoutError } from './errors';
 import type { DropResponse, Digest } from './types';
 
 /** A normal Error with the response's HTTP status attached, so callers can branch on it directly. */
@@ -12,14 +21,16 @@ export interface DropClient {
   waitUntilReady(deploy: DropResponse, token: string): Promise<void>;
 }
 
-const API = 'https://api.netlify.com/api/v1';
-
 /**
  * Unauthenticated drop client. Authorized server-side by the Referer header,
  * so it only works from an allowlisted origin (see backend checklist).
  */
 export class AnonymousDropClient implements DropClient {
-  constructor(private apiBase = API) {}
+  constructor(
+    private apiBase = DEFAULT_API_BASE,
+    private pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
+    private timeoutMs = DEFAULT_TIMEOUT_MS
+  ) {}
 
   async getToken(): Promise<string> {
     const res = await fetch(`${this.apiBase}/drop/token`, { method: 'POST' });
@@ -57,13 +68,14 @@ export class AnonymousDropClient implements DropClient {
     // Note: `/deploys/{id}` expects the deploy_id (BSON), not the site id (UUID)
     // that lives at `deploy.id`. See drop_controller.rb; Deploy.find(uuid) is nil
     // and the request 401s misleadingly via require_current_actor!.
-    for (let i = 0; i < 600; i++) {
+    const deadline = this.timeoutMs / this.pollIntervalMs;
+    for (let i = 0; i < deadline; i++) {
       const res = await fetch(`${this.apiBase}/deploys/${deploy.deploy_id}`, {
         headers: { Authorization: `Bearer ${token}` },
       });
       if (res.ok && (await res.json()).state === 'ready') return;
-      await new Promise(r => setTimeout(r, 1000));
+      await new Promise(r => setTimeout(r, this.pollIntervalMs));
     }
-    throw new Error('Deploy did not become ready in time');
+    throw new DeployTimeoutError();
   }
 }

package/packages/drop-core/constants.ts

@@ -0,0 +1,39 @@
+/**
+ * The tunables shared across drop-core, one place and one comment each.
+ * Module-specific constants (e.g. buildStash's storage caps) stay with their
+ * module; anything two modules read belongs here.
+ */
+
+/**
+ * Root for session-cookie JSON calls, via the consumer's access-control
+ * rewrite. On netlify.com, `/access-control/*` targets the app's
+ * access-control function; the paths an origin may call are allowlisted
+ * server-side.
+ */
+export const DEFAULT_PROXY_BASE = '/access-control/bb-api/api/v1';
+
+/** Direct api.netlify.com root for the uploads the proxy's ~6MB Lambda body limit can't carry. */
+export const DEFAULT_API_BASE = 'https://api.netlify.com/api/v1';
+
+// How often a waiting deploy/build is re-read: 1 second
+export const DEFAULT_POLL_INTERVAL_MS = 1000;
+
+// How long to keep polling before giving up: 10 minutes
+export const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+
+// Concurrent file uploads (matches netlify-cli's deploy engine)
+export const MAX_CONCURRENT_UPLOADS = 5;
+
+/**
+ * How long a minted upload token is reused before minting another: 20 seconds.
+ * The server issues non-app origins a 30s token; the gap leaves margin for the
+ * request the token authorizes to finish.
+ */
+export const TOKEN_REUSE_MS = 20 * 1000;
+
+/**
+ * Waits between attempts of a failed file upload, as data so the whole curve
+ * can be overridden (the tus-js-client `retryDelays` idiom). Three retries,
+ * linear backoff; 400/422 responses never retry — see `uploadWithRetry`.
+ */
+export const UPLOAD_RETRY_DELAYS_MS: readonly number[] = [1_000, 2_000, 3_000];

package/packages/drop-core/deploy.test.ts

@@ -0,0 +1,177 @@
+import { describe, expect, it, vi } from 'vitest';
+import { deployBuild, deployFiles } from './deploy';
+import type { BuildClient } from './buildClient';
+import type { DropClient } from './client';
+import type { DeployProgress, ProcessedFile } from './types';
+
+const encoder = new TextEncoder();
+
+const file = (path: string, sha: string, contents = 'x'): ProcessedFile => {
+  const content = encoder.encode(contents).buffer as ArrayBuffer;
+  return { path, sha, content, size: content.byteLength, name: path.split('/').pop()! };
+};
+
+const files = [file('/index.html', 'aaa'), file('/site.css', 'bbb'), file('/app.js', 'ccc')];
+
+function stubDropClient(required: string[]) {
+  const uploaded: string[] = [];
+  let inFlight = 0;
+  let maxInFlight = 0;
+  const client: DropClient = {
+    getToken: vi.fn(async () => 'tok'),
+    createDeploy: vi.fn(async () => ({
+      id: 'site',
+      deploy_id: 'deploy',
+      subdomain: 'sub',
+      required,
+    })),
+    uploadFile: vi.fn(async (deployId: string, path: string) => {
+      inFlight++;
+      maxInFlight = Math.max(maxInFlight, inFlight);
+      await new Promise(r => setTimeout(r, 2));
+      uploaded.push(`${deployId}:${path}`);
+      inFlight--;
+    }),
+    waitUntilReady: vi.fn(async () => {}),
+  };
+  return { client, uploaded, maxConcurrent: () => maxInFlight };
+}
+
+describe('deployFiles', () => {
+  it('uploads only the SHAs the backend reported missing, keyed by deploy_id', async () => {
+    const { client, uploaded } = stubDropClient(['aaa', 'ccc']);
+    const result = await deployFiles(client, files);
+    expect(uploaded.sort()).toEqual(['deploy:/app.js', 'deploy:/index.html']);
+    expect(result.url).toBe('https://sub.netlify.app');
+    expect(result.token).toBe('tok');
+    expect(client.waitUntilReady).toHaveBeenCalledWith(
+      expect.objectContaining({ deploy_id: 'deploy' }),
+      'tok'
+    );
+  });
+
+  it('never runs more than five uploads at once', async () => {
+    const many = Array.from({ length: 20 }, (_, i) => file(`/f${i}.txt`, `sha${i}`));
+    const { client, maxConcurrent } = stubDropClient(many.map(f => f.sha));
+    await deployFiles(client, many);
+    expect(maxConcurrent()).toBeLessThanOrEqual(5);
+  });
+
+  it('reports progress through the full phase sequence', async () => {
+    const { client } = stubDropClient(['aaa']);
+    const phases: DeployProgress[] = [];
+    await deployFiles(client, files, { onProgress: e => phases.push(e) });
+    expect(phases.map(p => p.phase)).toEqual([
+      'creating',
+      'uploading',
+      'uploading',
+      'processing',
+      'ready',
+    ]);
+    expect(phases[1]).toEqual({ phase: 'uploading', uploaded: 0, total: 1 });
+  });
+
+  it('retries a transient upload failure and succeeds', async () => {
+    const { client } = stubDropClient(['aaa']);
+    let attempts = 0;
+    (client.uploadFile as ReturnType<typeof vi.fn>).mockImplementation(async () => {
+      if (++attempts === 1) throw Object.assign(new Error('upload failed: 502'), { status: 502 });
+    });
+    await deployFiles(client, files, { retryDelays: [0, 0] });
+    expect(attempts).toBe(2);
+  });
+
+  it('gives up once the retry curve is exhausted', async () => {
+    const { client } = stubDropClient(['aaa']);
+    let attempts = 0;
+    (client.uploadFile as ReturnType<typeof vi.fn>).mockImplementation(async () => {
+      attempts++;
+      throw Object.assign(new Error('upload failed: 503'), { status: 503 });
+    });
+    await expect(deployFiles(client, files, { retryDelays: [0, 0] })).rejects.toThrow('503');
+    expect(attempts).toBe(3); // initial try + one per delay
+  });
+
+  it('never retries a 400/422 — the request itself is wrong', async () => {
+    const { client } = stubDropClient(['aaa']);
+    let attempts = 0;
+    (client.uploadFile as ReturnType<typeof vi.fn>).mockImplementation(async () => {
+      attempts++;
+      throw Object.assign(new Error('upload failed: 422'), { status: 422 });
+    });
+    await expect(deployFiles(client, files, { retryDelays: [0, 0] })).rejects.toThrow('422');
+    expect(attempts).toBe(1);
+  });
+
+  it('retries statusless network failures too', async () => {
+    const { client } = stubDropClient(['aaa']);
+    let attempts = 0;
+    (client.uploadFile as ReturnType<typeof vi.fn>).mockImplementation(async () => {
+      if (++attempts === 1) throw new TypeError('fetch failed');
+    });
+    await deployFiles(client, files, { retryDelays: [0] });
+    expect(attempts).toBe(2);
+  });
+
+  it('throws on an empty file set before any network call', async () => {
+    const { client } = stubDropClient([]);
+    await expect(deployFiles(client, [])).rejects.toThrow('No files to deploy');
+    expect(client.getToken).not.toHaveBeenCalled();
+  });
+});
+
+describe('deployBuild', () => {
+  const stubBuildClient = (): BuildClient & { calls: string[] } => {
+    const calls: string[] = [];
+    return {
+      calls,
+      createSite: vi.fn(async () => (calls.push('createSite'), { id: 'site', name: 'sub' })),
+      createBuildFromZip: vi.fn(
+        async () => (calls.push('createBuildFromZip'), { id: 'b', deploy_id: 'd' })
+      ),
+      waitUntilBuildReady: vi.fn(async () => {
+        calls.push('waitUntilBuildReady');
+      }),
+    };
+  };
+
+  it('zips, creates the site, uploads, and reports the site URL', async () => {
+    const client = stubBuildClient();
+    const result = await deployBuild(client, files);
+    expect(result.site.name).toBe('sub');
+    expect(result.build.deploy_id).toBe('d');
+    expect(result.url).toBe('https://sub.netlify.app');
+    // Off by default: the useful hand-off is the project page, not a spinner.
+    expect(client.waitUntilBuildReady).not.toHaveBeenCalled();
+  });
+
+  it('zips BEFORE creating the site, so a failed zip leaves no empty project behind', async () => {
+    const client = stubBuildClient();
+    // An empty file set makes zipFiles throw before any client call.
+    await expect(deployBuild(client, [])).rejects.toThrow('No files to deploy');
+    expect(client.createSite).not.toHaveBeenCalled();
+  });
+
+  it('waits for the build only when asked', async () => {
+    const client = stubBuildClient();
+    await deployBuild(client, files, { waitForBuild: true });
+    expect(client.calls).toEqual(['createSite', 'createBuildFromZip', 'waitUntilBuildReady']);
+  });
+
+  it('reports progress through the build phase sequence', async () => {
+    const client = stubBuildClient();
+    const phases: string[] = [];
+    await deployBuild(client, files, { onProgress: e => phases.push(e.phase) });
+    expect(phases).toEqual(['zipping', 'creating', 'uploading', 'building', 'ready']);
+  });
+
+  it('falls back through ssl_url → url → derived netlify.app domain', async () => {
+    const client = stubBuildClient();
+    (client.createSite as ReturnType<typeof vi.fn>).mockResolvedValue({
+      id: 's',
+      name: 'sub',
+      url: 'http://custom.example',
+    });
+    expect((await deployBuild(client, files)).url).toBe('http://custom.example');
+  });
+});

package/packages/{components/preact/DropZone/drop-core → drop-core}/deploy.ts

@@ -1,11 +1,38 @@
+import { MAX_CONCURRENT_UPLOADS, UPLOAD_RETRY_DELAYS_MS } from './constants';
 import { getDigest } from './digest';
 import type { BuildClient, BuildResponse, BuildSite } from './buildClient';
 import type { DropClient } from './client';
 import type { InferredBuildSettings } from './detectBuild';
 import type { DeployProgress, DeployResult, ProcessedFile } from './types';
-import { zipFiles } from './zip';
+import { zipFiles, type ZipResult } from './zip';
 
-const MAX_CONCURRENT_UPLOADS = 5;
+/** Responses that mean the request itself is wrong — retrying can only repeat the answer. */
+const NON_RETRIABLE_STATUSES = new Set([400, 422]);
+
+/**
+ * Upload one file, retrying transient failures (5xx, 429, network errors) on
+ * the given delay curve. A single flaky PUT among hundreds shouldn't kill the
+ * whole deploy — every deploy client we know of retries here.
+ */
+async function uploadWithRetry(
+  client: DropClient,
+  deployId: string,
+  file: ProcessedFile,
+  token: string,
+  retryDelays: readonly number[]
+): Promise<void> {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await client.uploadFile(deployId, file.path, file.content, token);
+      return;
+    } catch (err) {
+      const status = (err as { status?: number }).status;
+      if (status !== undefined && NON_RETRIABLE_STATUSES.has(status)) throw err;
+      if (attempt >= retryDelays.length) throw err;
+      await new Promise(r => setTimeout(r, retryDelays[attempt]));
+    }
+  }
+}
 
 async function uploadRequired(
   client: DropClient,
@@ -13,6 +40,7 @@ async function uploadRequired(
   files: ProcessedFile[],
   required: Set<string>,
   token: string,
+  retryDelays: readonly number[],
   onUploaded?: (uploaded: number) => void
 ) {
   const queue = files.filter(f => required.has(f.sha));
@@ -21,7 +49,7 @@ async function uploadRequired(
   const worker = async () => {
     while (cursor < queue.length) {
       const f = queue[cursor++];
-      await client.uploadFile(deployId, f.path, f.content, token);
+      await uploadWithRetry(client, deployId, f, token, retryDelays);
       onUploaded?.(++done);
     }
   };
@@ -30,6 +58,8 @@ async function uploadRequired(
 
 export interface DeployOptions {
   onProgress?: (e: DeployProgress) => void;
+  /** Waits between retries of a failed file upload. Override for tests or a different curve. */
+  retryDelays?: readonly number[];
 }
 
 export async function deployFiles(
@@ -38,7 +68,7 @@ export async function deployFiles(
   opts: DeployOptions = {}
 ): Promise<DeployResult> {
   if (!files.length) throw new Error('No files to deploy');
-  const { onProgress } = opts;
+  const { onProgress, retryDelays = UPLOAD_RETRY_DELAYS_MS } = opts;
 
   onProgress?.({ phase: 'creating' });
   const token = await client.getToken();
@@ -48,8 +78,14 @@ export async function deployFiles(
   onProgress?.({ phase: 'uploading', uploaded: 0, total });
   // File PUTs and readiness polling both key off `deploy_id` (BSON), NOT
   // `deploy.id` (the site UUID) — see the note in client.waitUntilReady.
-  await uploadRequired(client, deploy.deploy_id, files, new Set(deploy.required), token, uploaded =>
-    onProgress?.({ phase: 'uploading', uploaded, total })
+  await uploadRequired(
+    client,
+    deploy.deploy_id,
+    files,
+    new Set(deploy.required),
+    token,
+    retryDelays,
+    uploaded => onProgress?.({ phase: 'uploading', uploaded, total })
   );
 
   onProgress?.({ phase: 'processing' });
@@ -95,10 +131,24 @@ export async function deployBuild(
   opts: BuildDeployOptions = {}
 ): Promise<BuildDeployResult> {
   if (!files.length) throw new Error('No files to deploy');
-  const { onProgress, waitForBuild = false } = opts;
 
-  onProgress?.({ phase: 'zipping' });
-  const { file: zip, buildSettings } = await zipFiles(files);
+  opts.onProgress?.({ phase: 'zipping' });
+  const archive = await zipFiles(files);
+
+  return deployZippedBuild(client, archive, opts);
+}
+
+/**
+ * Deploy an archive that was already zipped — the resume path for a drop
+ * stashed across the signup round-trip (see `buildStash`), where `source.zip`
+ * and its synthesised settings were produced before the visitor left.
+ */
+export async function deployZippedBuild(
+  client: BuildClient,
+  { file: zip, buildSettings }: ZipResult,
+  opts: BuildDeployOptions = {}
+): Promise<BuildDeployResult> {
+  const { onProgress, waitForBuild = false } = opts;
 
   onProgress?.({ phase: 'creating' });
   const site = await client.createSite();

package/packages/drop-core/detectBuild.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it } from 'vitest';
+import { detectBuild, inferBuildSettings } from './detectBuild';
+import type { ProcessedFile } from './types';
+
+const encoder = new TextEncoder();
+
+const file = (path: string, contents = ''): ProcessedFile => {
+  const content = encoder.encode(contents).buffer as ArrayBuffer;
+  return { path, content, size: content.byteLength, sha: 'test-sha', name: path.split('/').pop()! };
+};
+
+const packageJson = (json: object) => file('/package.json', JSON.stringify(json));
+const staticSite = () => [file('/index.html', '<h1>hi</h1>'), file('/style.css', 'body{}')];
+
+describe('detectBuild', () => {
+  it('treats a plain static site as deployable without a build', () => {
+    expect(detectBuild(staticSite())).toEqual({ buildRequired: false, reason: null });
+  });
+
+  it('requires a build for a netlify.toml [build] table', () => {
+    const files = [
+      ...staticSite(),
+      file('/netlify.toml', '[build]\n  command = "npm run build"\n'),
+    ];
+    expect(detectBuild(files)).toEqual({ buildRequired: true, reason: 'netlify-toml-build' });
+  });
+
+  it('counts [build] sub-tables like [build.environment]', () => {
+    const files = [...staticSite(), file('/netlify.toml', '[build.environment]\n  FOO = "1"\n')];
+    expect(detectBuild(files)).toEqual({ buildRequired: true, reason: 'netlify-toml-build' });
+  });
+
+  it('ignores a [build] mention inside a comment', () => {
+    const files = [
+      ...staticSite(),
+      file('/netlify.toml', '# [build] used to live here\n[[redirects]]\n'),
+    ];
+    expect(detectBuild(files)).toEqual({ buildRequired: false, reason: null });
+  });
+
+  it('requires a build for a package.json build script', () => {
+    const files = [...staticSite(), packageJson({ scripts: { build: 'vite build' } })];
+    expect(detectBuild(files)).toEqual({
+      buildRequired: true,
+      reason: 'package-json-build-script',
+    });
+  });
+
+  it('does not count an empty build script', () => {
+    const files = [...staticSite(), packageJson({ scripts: { build: '  ' } })];
+    expect(detectBuild(files)).toEqual({ buildRequired: false, reason: null });
+  });
+
+  it('requires a build for a known framework dependency, prod or dev', () => {
+    expect(detectBuild([packageJson({ dependencies: { astro: '^4.0.0' } })])).toEqual({
+      buildRequired: true,
+      reason: 'framework-dependency',
+    });
+    expect(detectBuild([packageJson({ devDependencies: { vite: '^6.0.0' } })])).toEqual({
+      buildRequired: true,
+      reason: 'framework-dependency',
+    });
+  });
+
+  it('requires a build for the zero-config functions directories', () => {
+    expect(
+      detectBuild([...staticSite(), file('/netlify/functions/hello.ts', 'export {}')])
+    ).toEqual({
+      buildRequired: true,
+      reason: 'functions-directory',
+    });
+    expect(
+      detectBuild([...staticSite(), file('/netlify/edge-functions/hello.ts', 'export {}')])
+    ).toEqual({ buildRequired: true, reason: 'functions-directory' });
+  });
+
+  it('falls through on a malformed package.json rather than guessing', () => {
+    expect(detectBuild([...staticSite(), file('/package.json', '{ not json')])).toEqual({
+      buildRequired: false,
+      reason: null,
+    });
+  });
+
+  it('reports the first matching signal when several apply', () => {
+    const files = [
+      file('/netlify.toml', '[build]\n'),
+      packageJson({ scripts: { build: 'x' }, dependencies: { astro: '1' } }),
+    ];
+    expect(detectBuild(files).reason).toBe('netlify-toml-build');
+  });
+});
+
+describe('inferBuildSettings', () => {
+  const buildable = (extra: object = {}) =>
+    packageJson({ scripts: { build: 'astro build' }, dependencies: { astro: '^4' }, ...extra });
+
+  it('returns command + publish + framework when both halves are known', () => {
+    expect(inferBuildSettings([buildable()])).toEqual({
+      command: 'npm run build',
+      publish: 'dist',
+      framework: 'astro',
+    });
+  });
+
+  it('names the package manager from the lockfile', () => {
+    expect(inferBuildSettings([buildable(), file('/pnpm-lock.yaml')])?.command).toBe(
+      'pnpm run build'
+    );
+    expect(inferBuildSettings([buildable(), file('/yarn.lock')])?.command).toBe('yarn run build');
+    expect(inferBuildSettings([buildable(), file('/bun.lock')])?.command).toBe('bun run build');
+  });
+
+  it('defers to an existing [build] table — the author config wins', () => {
+    expect(
+      inferBuildSettings([buildable(), file('/netlify.toml', '[build]\n  publish = "out"\n')])
+    ).toBeNull();
+  });
+
+  it('still synthesises when the toml has only sub-tables (no [build] itself)', () => {
+    expect(
+      inferBuildSettings([buildable(), file('/netlify.toml', '[build.environment]\n  A = "1"\n')])
+    ).not.toBeNull();
+  });
+
+  it('returns null without a build script — no command to state', () => {
+    expect(inferBuildSettings([packageJson({ dependencies: { astro: '^4' } })])).toBeNull();
+  });
+
+  it('returns null for frameworks whose publish directory is not a fixed default', () => {
+    // Guessing publish wrong ships source instead of output — worse than not guessing.
+    expect(
+      inferBuildSettings([packageJson({ scripts: { build: 'x' }, dependencies: { nuxt: '^3' } })])
+    ).toBeNull();
+  });
+
+  it('returns null when no known framework is present', () => {
+    expect(inferBuildSettings([packageJson({ scripts: { build: 'make site' } })])).toBeNull();
+  });
+});

package/packages/drop-core/digest.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { getDigest } from './digest';
+import type { ProcessedFile } from './types';
+
+const file = (path: string, sha: string): ProcessedFile => ({
+  path,
+  sha,
+  size: 0,
+  content: new ArrayBuffer(0),
+  name: path.split('/').pop()!,
+});
+
+describe('getDigest', () => {
+  it('maps each path to its sha', () => {
+    expect(getDigest([file('/index.html', 'aaa'), file('/css/site.css', 'bbb')])).toEqual({
+      '/index.html': 'aaa',
+      '/css/site.css': 'bbb',
+    });
+  });
+
+  it('returns an empty digest for an empty file set', () => {
+    expect(getDigest([])).toEqual({});
+  });
+});

package/packages/drop-core/errors.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from 'vitest';
+import { apiError } from './client';
+import {
+  BuildCreateError,
+  BuildFailedError,
+  BuildTimeoutError,
+  DeployFailedError,
+  DeployTimeoutError,
+  humanizeDropError,
+  isNotAuthenticatedError,
+  NotAuthenticatedError,
+  SiteCreateError,
+  UnsupportedDropError,
+} from './errors';
+
+describe('error codes', () => {
+  it('pins each class to its copy-proof code brand', () => {
+    expect(new UnsupportedDropError().code).toBe('unsupported-drop');
+    expect(new NotAuthenticatedError().code).toBe('not-authenticated');
+    expect(new SiteCreateError().code).toBe('site-create-failed');
+    expect(new BuildCreateError().code).toBe('build-create-failed');
+    expect(new BuildFailedError().code).toBe('build-failed');
+    expect(new BuildTimeoutError().code).toBe('build-timeout');
+    expect(new DeployFailedError().code).toBe('deploy-failed');
+    expect(new DeployTimeoutError().code).toBe('deploy-timeout');
+  });
+
+  it('recognizes a foreign-copy NotAuthenticatedError by its code', () => {
+    // Raw-TS and dist entrypoints can each load their own class copy;
+    // instanceof fails across copies, the code brand does not.
+    const foreignCopy = Object.assign(new Error('not authenticated'), {
+      code: 'not-authenticated',
+    });
+    expect(isNotAuthenticatedError(foreignCopy)).toBe(true);
+    expect(isNotAuthenticatedError(new Error('nope'))).toBe(false);
+    expect(isNotAuthenticatedError('not-authenticated')).toBe(false);
+  });
+});
+
+describe('humanizeDropError', () => {
+  it('maps each typed error to its user-facing copy', () => {
+    expect(humanizeDropError(new UnsupportedDropError())).toBe(
+      'To deploy, drop a folder or a .zip file — or a single HTML page.'
+    );
+    expect(humanizeDropError(new SiteCreateError(500))).toBe(
+      "We couldn't create a project for this build. Please try again."
+    );
+    expect(humanizeDropError(new BuildTimeoutError())).toBe(
+      'Your build is taking longer than expected. It may still finish — check your Netlify dashboard.'
+    );
+  });
+
+  it("passes a failed build's own message through — the only actionable part", () => {
+    expect(humanizeDropError(new BuildFailedError('Command failed: npm run build'))).toBe(
+      'Your build failed: Command failed: npm run build'
+    );
+    expect(humanizeDropError(new BuildFailedError())).toBe(
+      'Your build failed. Check your build settings and try again.'
+    );
+  });
+
+  it('maps API statuses attached by apiError()', () => {
+    expect(humanizeDropError(apiError('drop', 429))).toContain('Too many attempts');
+    expect(humanizeDropError(apiError('upload /x', 413))).toContain('too large');
+    expect(humanizeDropError(apiError('poll', 404))).toContain("couldn't find that deploy");
+    expect(humanizeDropError(apiError('drop', 401))).toContain("wasn't allowed");
+    expect(humanizeDropError(apiError('drop', 503))).toContain('servers are having trouble');
+  });
+
+  it('routes typed errors carrying a status through the same mapping', () => {
+    expect(humanizeDropError(new BuildCreateError(413))).toContain('too large');
+  });
+
+  it('maps the deploy timeout and failure classes', () => {
+    expect(humanizeDropError(new DeployTimeoutError())).toContain('taking longer than expected');
+    expect(humanizeDropError(new DeployFailedError('no index.html'))).toBe(
+      'Your deploy failed: no index.html'
+    );
+    expect(humanizeDropError(new DeployFailedError())).toBe('Your deploy failed. Please try again.');
+  });
+
+  it('reads a fetch TypeError as a connectivity problem', () => {
+    expect(humanizeDropError(new TypeError('Failed to fetch'))).toContain(
+      'Check your internet connection'
+    );
+  });
+
+  it('falls back to generic copy for anything else', () => {
+    expect(humanizeDropError('not even an error')).toBe('Something went wrong. Please try again.');
+    expect(humanizeDropError(new Error('mystery'))).toBe('Something went wrong. Please try again.');
+  });
+
+  it('keeps the NotAuthenticatedError copy path-agnostic — it gates static deploys and builds alike', () => {
+    expect(humanizeDropError(new NotAuthenticatedError())).toBe(
+      'Please log in to Netlify to deploy this project, then try again.'
+    );
+  });
+});