@netlify/spark-ui 1.31.0-alpha.4 → 1.31.0-alpha.6

package/dist/drop-core/deploy.d.ts

@@ -5,10 +5,11 @@ import { DeployProgress, DeployResult, ProcessedFile } from './types';
 import { ZipResult } from './zip';
 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 declare function deployFiles(client: DropClient, files: ProcessedFile[], opts?: DeployOptions): Promise<DeployResult>;
 export interface BuildDeployResult {
-    /** The site created for this build. */
     site: BuildSite;
     /** The enqueued build; `deploy_id` is what the app's deploy page keys off. */
     build: BuildResponse;
@@ -19,26 +20,15 @@ export interface BuildDeployResult {
 }
 export interface BuildDeployOptions extends DeployOptions {
     /**
-     * Poll until the build finishes instead of returning as soon as it's enqueued.
-     * Off by default: a build takes minutes, so the useful hand-off is usually the
-     * app's deploy page with its live logs, not a spinner. Turn it on when the
-     * caller needs to know the outcome — only then can a `BuildFailedError` reach
-     * it with the build's own error message.
+     * Wait for the build instead of returning at enqueue. Off by default (builds
+     * take minutes); on is the only way a BuildFailedError reaches the caller.
      */
     waitForBuild?: boolean;
 }
 /**
- * The build counterpart to `deployFiles`: zip the drop, create a site in the
- * user's account, and hand the archive to buildbot. Requires an authenticated
- * client — builds have no anonymous equivalent.
- *
- * Site creation deliberately happens *after* zipping, so a zip that fails
- * doesn't leave an empty site behind in the user's account.
+ * Zip the drop, create a site, hand buildbot the archive. Zipping comes first
+ * on purpose: a failed zip must not leave an empty site behind.
  */
 export declare function deployBuild(client: BuildClient, files: ProcessedFile[], opts?: BuildDeployOptions): Promise<BuildDeployResult>;
-/**
- * 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.
- */
+/** Deploy an already-zipped archive — the resume path for a stashed drop (see `buildStash`). */
 export declare function deployZippedBuild(client: BuildClient, { file: zip, buildSettings }: ZipResult, opts?: BuildDeployOptions): Promise<BuildDeployResult>;

package/dist/drop-core/deploy.js

@@ -1,53 +1,66 @@
-import { getDigest as w } from "./digest.js";
-import { zipFiles as y } from "./zip.js";
-const r = 5;
-async function f(i, n, p, a, t, e) {
-  const l = p.filter((h) => a.has(h.sha));
-  let u = 0, c = 0;
+import { UPLOAD_RETRY_DELAYS_MS as w, MAX_CONCURRENT_UPLOADS as o } from "./constants.js";
+import { getDigest as y } from "./digest.js";
+import { zipFiles as f } from "./zip.js";
+const s = /* @__PURE__ */ new Set([400, 422]);
+async function m(e, l, n, t, a) {
+  for (let u = 0; ; u++)
+    try {
+      await e.uploadFile(l, n.path, n.content, t);
+      return;
+    } catch (i) {
+      const p = i.status;
+      if (p !== void 0 && s.has(p) || u >= a.length) throw i;
+      await new Promise((h) => setTimeout(h, a[u]));
+    }
+}
+async function R(e, l, n, t, a, u, i) {
+  const p = n.filter((c) => t.has(c.sha));
+  let h = 0, r = 0;
   const d = async () => {
-    for (; u < l.length; ) {
-      const h = l[u++];
-      await i.uploadFile(n, h.path, h.content, t), e == null || e(++c);
+    for (; h < p.length; ) {
+      const c = p[h++];
+      await m(e, l, c, a, u), i == null || i(++r);
     }
   };
-  await Promise.all(Array.from({ length: Math.min(r, l.length) }, d));
+  await Promise.all(Array.from({ length: Math.min(o, p.length) }, d));
 }
-async function B(i, n, p = {}) {
-  if (!n.length) throw new Error("No files to deploy");
-  const { onProgress: a } = p;
-  a == null || a({ phase: "creating" });
-  const t = await i.getToken(), e = await i.createDeploy(w(n), t), l = e.required.length;
-  return a == null || a({ phase: "uploading", uploaded: 0, total: l }), await f(
-    i,
-    e.deploy_id,
-    n,
-    new Set(e.required),
-    t,
-    (u) => a == null ? void 0 : a({ phase: "uploading", uploaded: u, total: l })
-  ), a == null || a({ phase: "processing" }), await i.waitUntilReady(e, t), a == null || a({ phase: "ready" }), { deploy: e, token: t, url: `https://${e.subdomain}.netlify.app` };
+async function T(e, l, n = {}) {
+  if (!l.length) throw new Error("No files to deploy");
+  const { onProgress: t, retryDelays: a = w } = n;
+  t == null || t({ phase: "creating" });
+  const u = await e.getToken(), i = await e.createDeploy(y(l), u), p = i.required.length;
+  return t == null || t({ phase: "uploading", uploaded: 0, total: p }), await R(
+    e,
+    i.deploy_id,
+    l,
+    new Set(i.required),
+    u,
+    a,
+    (h) => t == null ? void 0 : t({ phase: "uploading", uploaded: h, total: p })
+  ), t == null || t({ phase: "processing" }), await e.waitUntilReady(i, u), t == null || t({ phase: "ready" }), { deploy: i, token: u, url: `https://${i.subdomain}.netlify.app` };
 }
-async function F(i, n, p = {}) {
-  var t;
-  if (!n.length) throw new Error("No files to deploy");
-  (t = p.onProgress) == null || t.call(p, { phase: "zipping" });
-  const a = await y(n);
-  return o(i, a, p);
+async function B(e, l, n = {}) {
+  var a;
+  if (!l.length) throw new Error("No files to deploy");
+  (a = n.onProgress) == null || a.call(n, { phase: "zipping" });
+  const t = await f(l);
+  return S(e, t, n);
 }
-async function o(i, { file: n, buildSettings: p }, a = {}) {
-  const { onProgress: t, waitForBuild: e = !1 } = a;
-  t == null || t({ phase: "creating" });
-  const l = await i.createSite();
-  t == null || t({ phase: "uploading" });
-  const u = await i.createBuildFromZip(l.id, n);
-  return t == null || t({ phase: "building" }), e && await i.waitUntilBuildReady(u), t == null || t({ phase: "ready" }), {
-    site: l,
-    build: u,
-    buildSettings: p,
-    url: l.ssl_url || l.url || `https://${l.name}.netlify.app`
+async function S(e, { file: l, buildSettings: n }, t = {}) {
+  const { onProgress: a, waitForBuild: u = !1 } = t;
+  a == null || a({ phase: "creating" });
+  const i = await e.createSite();
+  a == null || a({ phase: "uploading" });
+  const p = await e.createBuildFromZip(i.id, l);
+  return a == null || a({ phase: "building" }), u && await e.waitUntilBuildReady(p), a == null || a({ phase: "ready" }), {
+    site: i,
+    build: p,
+    buildSettings: n,
+    url: i.ssl_url || i.url || `https://${i.name}.netlify.app`
   };
 }
 export {
-  F as deployBuild,
-  B as deployFiles,
-  o as deployZippedBuild
+  B as deployBuild,
+  T as deployFiles,
+  S as deployZippedBuild
 };

package/dist/drop-core/detectBuild.d.ts

@@ -2,23 +2,15 @@ import { ProcessedFile } from './types';
 /** Why a drop was judged to need a build — surfaced to analytics and `onBuildRequired`. */
 export type BuildReason = 'netlify-toml-build' | 'package-json-build-script' | 'framework-dependency' | 'functions-directory';
 export interface BuildDetection {
-    /** True when the dropped project needs a build step and can't be served as static files. */
+    /** The drop can't be served as static files. */
     buildRequired: boolean;
     /** The signal that decided it (first match wins), or null for a plain static drop. */
     reason: BuildReason | null;
 }
 /**
- * Decide whether a dropped project needs a build. Runs on the already-read,
- * root-normalized `ProcessedFile[]` (a dropped `.zip` is expanded and the common
- * root folder stripped upstream in `readFiles`), so build config sits at the
- * deploy root, e.g. `/netlify.toml`, `/package.json`.
- *
- * The anonymous drop API only performs static deploys, so a build-required
- * project can't go through it — the consumer redirects such drops to the
- * authenticated Drop page instead. This heuristic is deliberately lightweight
- * (no framework-detection dependency): it reads the two config files and looks
- * for the zero-config functions directories. A plain static site (HTML/CSS/JS,
- * no build config) returns `{ buildRequired: false }`.
+ * Does this drop need a build? Deliberately lightweight (two config files +
+ * the functions dirs; no framework-detection dependency). Input is
+ * root-normalized by `readFiles`, so config sits at `/netlify.toml` etc.
  */
 export declare function detectBuild(files: ProcessedFile[]): BuildDetection;
 /** Build settings confident enough to write into a `netlify.toml` for buildbot. */
@@ -31,19 +23,9 @@ export interface InferredBuildSettings {
     framework: string;
 }
 /**
- * Infer the build command and publish directory for a build-required drop, so
- * `zipFiles` can write them into a `netlify.toml` that buildbot reads.
- *
- * Deliberately conservative: it returns settings **only** when both halves are
- * known — a `build` script (which gives the command) and a recognised framework
- * with a fixed default publish directory (which gives the output). Anything else
- * returns `null`, leaving the zip without a synthesised `[build]` table so
- * buildbot's own framework detection resolves the settings instead. That matters
- * because a `[build]` table with a command but no `publish` makes buildbot
- * publish the deploy root — shipping the project's *source* rather than its
- * built output, which is worse than not guessing at all.
- *
- * Returns `null` too when the drop already declares a `[build]` table: the
- * author's own config always wins.
+ * Build settings for the synthesised netlify.toml — only when BOTH halves are
+ * known (build script → command, known framework → publish). Guessing publish
+ * wrong ships source instead of output, so `null` beats a bad guess. An
+ * author-declared [build] table always wins (also `null`).
  */
 export declare function inferBuildSettings(files: ProcessedFile[]): InferredBuildSettings | null;

package/dist/drop-core/errors.d.ts

@@ -1,26 +1,27 @@
 /**
- * Thrown when the user drops or picks a single loose file that Drop can't turn
- * into a site on its own — anything that isn't a `.zip` (a site archive) or an
- * HTML page (served as index.html). A folder, multiple files, a zip, or a lone
- * HTML file are all fine; any other single file is rejected rather than
- * deployed as a one-asset site (matches react-ui).
+ * A single loose file that can't stand up a site — only a zip, folder,
+ * multiple files, or a lone HTML page may deploy (matches react-ui).
  */
 export declare class UnsupportedDropError extends Error {
+    readonly code = "unsupported-drop";
     constructor();
 }
 /**
- * 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.
+ * The pre-mutation "no session" signal: nothing was created yet, so static
+ * drops may fall back to the anonymous flow and build drops stash + hand off.
  */
 export declare class NotAuthenticatedError extends Error {
+    readonly code = "not-authenticated";
     constructor(message?: string);
 }
+/**
+ * Copy-proof check for the "no session" error — `instanceof` misses class
+ * copies from the package's other entrypoint. Fallback gates must use this.
+ */
+export declare function isNotAuthenticatedError(err: unknown): err is NotAuthenticatedError;
 /** `POST …/sites` failed, so there is nothing to build into. Carries the HTTP status. */
 export declare class SiteCreateError extends Error {
+    readonly code = "site-create-failed";
     status?: number;
     constructor(status?: number);
 }
@@ -29,21 +30,30 @@ export declare class SiteCreateError extends Error {
  * started. Distinct from `BuildFailedError`, which is a build that ran and broke.
  */
 export declare class BuildCreateError extends Error {
+    readonly code = "build-create-failed";
     status?: number;
     constructor(status?: number);
 }
-/**
- * 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.
- */
+/** The build ran and broke. `reason` carries the API's `error_message` — the only actionable part. */
 export declare class BuildFailedError extends Error {
     reason?: string | undefined;
+    readonly code = "build-failed";
     constructor(reason?: string | undefined);
 }
 /** The build hadn't settled before the poller gave up. The build itself may still finish. */
 export declare class BuildTimeoutError extends Error {
+    readonly code = "build-timeout";
+    constructor();
+}
+/** A static deploy ran and ended in `error`/`rejected`; `reason` carries the API's `error_message`. */
+export declare class DeployFailedError extends Error {
+    reason?: string | undefined;
+    readonly code = "deploy-failed";
+    constructor(reason?: string | undefined);
+}
+/** The deploy hadn't gone ready before the poller gave up. It may still finish. */
+export declare class DeployTimeoutError extends Error {
+    readonly code = "deploy-timeout";
     constructor();
 }
 /**

package/dist/drop-core/errors.js

@@ -1,53 +1,87 @@
-var n = Object.defineProperty;
-var i = (e, t, r) => t in e ? n(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var a = (e, t, r) => i(e, typeof t != "symbol" ? t + "" : t, r);
-class o extends Error {
+var a = Object.defineProperty;
+var n = (e, r, t) => r in e ? a(e, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[r] = t;
+var o = (e, r, t) => n(e, typeof r != "symbol" ? r + "" : r, t);
+class l extends Error {
   constructor() {
-    super("unsupported single file"), this.name = "UnsupportedDropError";
+    super("unsupported single file");
+    o(this, "code", "unsupported-drop");
+    this.name = "UnsupportedDropError";
   }
 }
 class s extends Error {
   constructor(t = "not authenticated") {
-    super(t), this.name = "NotAuthenticatedError";
+    super(t);
+    o(this, "code", "not-authenticated");
+    this.name = "NotAuthenticatedError";
   }
 }
-class u extends Error {
-  constructor(r) {
-    super(`site create failed${r ? `: ${r}` : ""}`);
-    a(this, "status");
-    this.name = "SiteCreateError", this.status = r;
+function u(e) {
+  return e instanceof s ? !0 : e instanceof Error && e.code === "not-authenticated";
+}
+class c extends Error {
+  constructor(t) {
+    super(`site create failed${t ? `: ${t}` : ""}`);
+    o(this, "code", "site-create-failed");
+    o(this, "status");
+    this.name = "SiteCreateError", this.status = t;
+  }
+}
+class p extends Error {
+  constructor(t) {
+    super(`build create failed${t ? `: ${t}` : ""}`);
+    o(this, "code", "build-create-failed");
+    o(this, "status");
+    this.name = "BuildCreateError", this.status = t;
   }
 }
 class f extends Error {
-  constructor(r) {
-    super(`build create failed${r ? `: ${r}` : ""}`);
-    a(this, "status");
-    this.name = "BuildCreateError", this.status = r;
+  constructor(t) {
+    super(t ? `build failed: ${t}` : "build failed");
+    o(this, "code", "build-failed");
+    this.reason = t, this.name = "BuildFailedError";
   }
 }
-class l extends Error {
+class y extends Error {
+  constructor() {
+    super("Build did not finish in time");
+    o(this, "code", "build-timeout");
+    this.name = "BuildTimeoutError";
+  }
+}
+class h extends Error {
   constructor(t) {
-    super(t ? `build failed: ${t}` : "build failed"), this.reason = t, this.name = "BuildFailedError";
+    super(t ? `deploy failed: ${t}` : "deploy failed");
+    o(this, "code", "deploy-failed");
+    this.reason = t, this.name = "DeployFailedError";
   }
 }
-class d extends Error {
+class g extends Error {
   constructor() {
-    super("Build did not finish in time"), this.name = "BuildTimeoutError";
+    super("Deploy did not become ready in time");
+    o(this, "code", "deploy-timeout");
+    this.name = "DeployTimeoutError";
   }
 }
-function h(e) {
+function m(e) {
   if (!(e instanceof Error)) return "Something went wrong. Please try again.";
-  if (e instanceof o)
+  const r = e.code;
+  if (r === "unsupported-drop")
     return "To deploy, drop a folder or a .zip file — or a single HTML page.";
-  if (e instanceof s)
+  if (r === "not-authenticated")
     return "Please log in to Netlify to deploy this project, then try again.";
-  if (e instanceof u)
+  if (r === "site-create-failed")
     return "We couldn't create a project for this build. Please try again.";
-  if (e instanceof l)
-    return e.reason ? `Your build failed: ${e.reason}` : "Your build failed. Check your build settings and try again.";
-  if (e instanceof d)
+  if (r === "build-failed") {
+    const i = e.reason;
+    return i ? `Your build failed: ${i}` : "Your build failed. Check your build settings and try again.";
+  }
+  if (r === "deploy-failed") {
+    const i = e.reason;
+    return i ? `Your deploy failed: ${i}` : "Your deploy failed. Please try again.";
+  }
+  if (r === "build-timeout")
     return "Your build is taking longer than expected. It may still finish — check your Netlify dashboard.";
-  if (e.message === "Deploy did not become ready in time")
+  if (r === "deploy-timeout")
     return "Your site is taking longer than expected to go live. Please try again in a moment.";
   if (e instanceof TypeError)
     return "Couldn't connect to Netlify. Check your internet connection and try again.";
@@ -72,11 +106,14 @@ function h(e) {
   }
 }
 export {
-  f as BuildCreateError,
-  l as BuildFailedError,
-  d as BuildTimeoutError,
+  p as BuildCreateError,
+  f as BuildFailedError,
+  y as BuildTimeoutError,
+  h as DeployFailedError,
+  g as DeployTimeoutError,
   s as NotAuthenticatedError,
-  u as SiteCreateError,
-  o as UnsupportedDropError,
-  h as humanizeDropError
+  c as SiteCreateError,
+  l as UnsupportedDropError,
+  m as humanizeDropError,
+  u as isNotAuthenticatedError
 };

package/dist/drop-core/fileTypes.d.ts

@@ -1,17 +1,7 @@
 /**
- * Distinct MIME types across a drop or file-picker selection, sorted so the same
- * selection always yields the same array.
- *
- * Read from the raw `File.type` at the drop boundary rather than from
- * `ProcessedFile`s: the MIME type only exists on the original `File`, and reading
- * can throw before any `ProcessedFile` does (an unsupported single file) — the
- * very case the file type is most worth knowing about.
- *
- * Browsers leave `File.type` empty for anything they don't recognise — a dragged
- * folder, an `.exe`, an extensionless file — so those collapse to
- * `application/octet-stream` and the property never carries an empty string.
- *
- * Call this synchronously inside the drop handler: a `DataTransfer` detaches once
- * the event turn ends.
+ * Distinct, sorted MIME types of a selection. Read at the drop boundary — the
+ * type only exists on the original File, and reading can throw before any
+ * ProcessedFile exists. Call synchronously in the drop handler: a DataTransfer
+ * detaches after the event turn.
  */
 export declare function getFileTypes(files: FileList | null | undefined): string[];

package/dist/drop-core/index.d.ts

@@ -1,14 +1,25 @@
+/**
+ * The public surface of drop-core — nothing is public unless named here.
+ * `export *` is reserved for the three modules that are contracts in their
+ * entirety: types, errors, and the analytics event map.
+ */
 export * from './types';
-export * from './digest';
-export * from './readFiles';
-export * from './fileTypes';
-export * from './detectBuild';
-export * from './client';
-export * from './authedApi';
-export * from './authedDropClient';
-export * from './buildClient';
-export * from './zip';
-export * from './buildStash';
-export * from './deploy';
 export * from './errors';
 export * from './analytics';
+export { getSingleNonIndexHtmlFileName, hasMultipleHtmlFilesWithoutIndex, readDataTransfer, readFileList, renameSingleNonIndexHtmlToIndex, } from './readFiles';
+export { getFileTypes } from './fileTypes';
+export { detectBuild, inferBuildSettings } from './detectBuild';
+export type { BuildDetection, BuildReason, InferredBuildSettings } from './detectBuild';
+export { zipFiles } from './zip';
+export type { ZipOptions, ZipResult } from './zip';
+export { AnonymousDropClient } from './client';
+export type { DropClient } from './client';
+export { AuthenticatedDropClient } from './authedDropClient';
+export type { AuthenticatedDropClientConfig } from './authedDropClient';
+export { AuthenticatedBuildClient } from './buildClient';
+export type { AuthenticatedBuildClientConfig, BuildClient, BuildResponse } from './buildClient';
+export { deployBuild, deployFiles, deployZippedBuild } from './deploy';
+export type { BuildDeployOptions, BuildDeployResult, DeployOptions } from './deploy';
+export { clearDropStash, hasDropStashMarker, loadDropStash, saveDropStash } from './buildStash';
+export type { DropBuildStash } from './buildStash';
+export { DEFAULT_API_BASE, DEFAULT_PROXY_BASE, UPLOAD_RETRY_DELAYS_MS } from './constants';

package/dist/drop-core/index.js

@@ -1,51 +1,47 @@
-import { getDigest as o } from "./digest.js";
-import { getSingleNonIndexHtmlFileName as i, hasMultipleHtmlFilesWithoutIndex as l, readDataTransfer as p, readFileList as a, renameSingleNonIndexHtmlToIndex as d } from "./readFiles.js";
-import { getFileTypes as m } from "./fileTypes.js";
-import { detectBuild as u, inferBuildSettings as s } from "./detectBuild.js";
-import { AnonymousDropClient as f, apiError as D } from "./client.js";
-import { DEFAULT_API_BASE as A, DEFAULT_POLL_INTERVAL_MS as T, DEFAULT_PROXY_BASE as h, DEFAULT_TIMEOUT_MS as F, createSiteInAccount as B, pollDeployUntilSettled as _ } from "./authedApi.js";
-import { AuthenticatedDropClient as g } from "./authedDropClient.js";
-import { AuthenticatedBuildClient as L } from "./buildClient.js";
-import { generateNetlifyToml as y, zipFiles as U } from "./zip.js";
-import { clearDropStash as M, hasDropStashMarker as O, loadDropStash as P, saveDropStash as H } from "./buildStash.js";
-import { deployBuild as z, deployFiles as V, deployZippedBuild as Z } from "./deploy.js";
-import { BuildCreateError as v, BuildFailedError as W, BuildTimeoutError as X, NotAuthenticatedError as Y, SiteCreateError as b, UnsupportedDropError as j, humanizeDropError as q } from "./errors.js";
-import { DROPZONE_EVENTS as G } from "./analytics.js";
+import { BuildCreateError as o, BuildFailedError as t, BuildTimeoutError as i, DeployFailedError as l, DeployTimeoutError as p, NotAuthenticatedError as d, SiteCreateError as a, UnsupportedDropError as n, humanizeDropError as m, isNotAuthenticatedError as u } from "./errors.js";
+import { DROPZONE_EVENTS as s } from "./analytics.js";
+import { getSingleNonIndexHtmlFileName as D, hasMultipleHtmlFilesWithoutIndex as f, readDataTransfer as S, readFileList as h, renameSingleNonIndexHtmlToIndex as A } from "./readFiles.js";
+import { getFileTypes as F } from "./fileTypes.js";
+import { detectBuild as _, inferBuildSettings as y } from "./detectBuild.js";
+import { zipFiles as c } from "./zip.js";
+import { AnonymousDropClient as C } from "./client.js";
+import { AuthenticatedDropClient as L } from "./authedDropClient.js";
+import { AuthenticatedBuildClient as P } from "./buildClient.js";
+import { deployBuild as U, deployFiles as H, deployZippedBuild as M } from "./deploy.js";
+import { clearDropStash as z, hasDropStashMarker as Z, loadDropStash as k, saveDropStash as v } from "./buildStash.js";
+import { DEFAULT_API_BASE as W, DEFAULT_PROXY_BASE as X, UPLOAD_RETRY_DELAYS_MS as b } from "./constants.js";
 export {
-  f as AnonymousDropClient,
-  L as AuthenticatedBuildClient,
-  g as AuthenticatedDropClient,
-  v as BuildCreateError,
-  W as BuildFailedError,
-  X as BuildTimeoutError,
-  A as DEFAULT_API_BASE,
-  T as DEFAULT_POLL_INTERVAL_MS,
-  h as DEFAULT_PROXY_BASE,
-  F as DEFAULT_TIMEOUT_MS,
-  G as DROPZONE_EVENTS,
-  Y as NotAuthenticatedError,
-  b as SiteCreateError,
-  j as UnsupportedDropError,
-  D as apiError,
-  M as clearDropStash,
-  B as createSiteInAccount,
-  z as deployBuild,
-  V as deployFiles,
-  Z as deployZippedBuild,
-  u as detectBuild,
-  y as generateNetlifyToml,
-  o as getDigest,
-  m as getFileTypes,
-  i as getSingleNonIndexHtmlFileName,
-  O as hasDropStashMarker,
-  l as hasMultipleHtmlFilesWithoutIndex,
-  q as humanizeDropError,
-  s as inferBuildSettings,
-  P as loadDropStash,
-  _ as pollDeployUntilSettled,
-  p as readDataTransfer,
-  a as readFileList,
-  d as renameSingleNonIndexHtmlToIndex,
-  H as saveDropStash,
-  U as zipFiles
+  C as AnonymousDropClient,
+  P as AuthenticatedBuildClient,
+  L as AuthenticatedDropClient,
+  o as BuildCreateError,
+  t as BuildFailedError,
+  i as BuildTimeoutError,
+  W as DEFAULT_API_BASE,
+  X as DEFAULT_PROXY_BASE,
+  s as DROPZONE_EVENTS,
+  l as DeployFailedError,
+  p as DeployTimeoutError,
+  d as NotAuthenticatedError,
+  a as SiteCreateError,
+  b as UPLOAD_RETRY_DELAYS_MS,
+  n as UnsupportedDropError,
+  z as clearDropStash,
+  U as deployBuild,
+  H as deployFiles,
+  M as deployZippedBuild,
+  _ as detectBuild,
+  F as getFileTypes,
+  D as getSingleNonIndexHtmlFileName,
+  Z as hasDropStashMarker,
+  f as hasMultipleHtmlFilesWithoutIndex,
+  m as humanizeDropError,
+  y as inferBuildSettings,
+  u as isNotAuthenticatedError,
+  k as loadDropStash,
+  S as readDataTransfer,
+  h as readFileList,
+  A as renameSingleNonIndexHtmlToIndex,
+  v as saveDropStash,
+  c as zipFiles
 };

package/dist/drop-core/readFiles.d.ts

@@ -1,21 +1,15 @@
 import { ProcessedFile } from './types';
 /**
- * Read a DataTransfer from a drop event into ProcessedFiles.
- *
- * NOTE: `webkitGetAsEntry()` must be called synchronously inside the drop
- * handler — the DataTransfer is detached once the event turn ends. The
- * component captures entries first (see `readDroppedEntries`) then calls the
- * async readers, so this function is safe to `await`.
+ * Read a drop's DataTransfer into ProcessedFiles. `webkitGetAsEntry()` runs
+ * synchronously before the first await — the DataTransfer detaches once the
+ * event turn ends.
  */
 export declare function readDataTransfer(dt: DataTransfer): Promise<ProcessedFile[]>;
 export declare function readFileList(files: FileList): Promise<ProcessedFile[]>;
 export declare function getSingleNonIndexHtmlFileName(files: ProcessedFile[]): string | null;
 export declare function hasMultipleHtmlFilesWithoutIndex(files: ProcessedFile[]): boolean;
 /**
- * When the set has no index.html but exactly one HTML file (a lone page
- * alongside its assets, or a single dropped file), rename that file to
- * index.html — keeping its directory — so it is served at the site root
- * instead of 404ing. Content and sha are untouched. Any other set (already has
- * an index, multiple HTML files, or no HTML) is returned unchanged.
+ * A lone non-index HTML page is renamed to index.html (same directory,
+ * content/sha untouched) so it serves instead of 404ing. Other sets unchanged.
  */
 export declare function renameSingleNonIndexHtmlToIndex(files: ProcessedFile[]): ProcessedFile[];

package/dist/drop-core/types.d.ts

@@ -9,10 +9,8 @@ export interface ProcessedFile {
 }
 export type Digest = Record<string, string>;
 /**
- * Response body of `POST /api/v1/drop`. Not a canonical Deploy resource —
- * it's a mixed shape carrying both the anonymous site and the initial deploy
- * so the client has everything it needs to upload, poll, and hand off to the
- * user in one round trip.
+ * Response of `POST /api/v1/drop` — a mixed site+deploy shape, everything the
+ * client needs to upload, poll, and hand off in one round trip.
  */
 export interface DropResponse {
     /** site id (UUID) — surfaced to callers so they can build claim links */