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

package/dist/drop-core/client.js

@@ -1,14 +1,15 @@
-function r(s, t) {
-  return Object.assign(new Error(`${s} failed: ${t}`), { status: t });
+import { DEFAULT_API_BASE as p, DEFAULT_POLL_INTERVAL_MS as l, DEFAULT_TIMEOUT_MS as h } from "./constants.js";
+import { DeployTimeoutError as d } from "./errors.js";
+function i(r, t) {
+  return Object.assign(new Error(`${r} failed: ${t}`), { status: t });
 }
-const n = "https://api.netlify.com/api/v1";
-class p {
-  constructor(t = n) {
-    this.apiBase = t;
+class y {
+  constructor(t = p, o = l, e = h) {
+    this.apiBase = t, this.pollIntervalMs = o, this.timeoutMs = e;
   }
   async getToken() {
     const t = await fetch(`${this.apiBase}/drop/token`, { method: "POST" });
-    if (!t.ok) throw r("drop/token", t.status);
+    if (!t.ok) throw i("drop/token", t.status);
     return (await t.json()).token;
   }
   async createDeploy(t, o) {
@@ -17,29 +18,30 @@ class p {
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ files: t, token: o })
     });
-    if (!e.ok) throw r("drop", e.status);
+    if (!e.ok) throw i("drop", e.status);
     return e.json();
   }
   async uploadFile(t, o, e, a) {
-    const i = await fetch(`${this.apiBase}/deploys/${t}/files${o}`, {
+    const s = await fetch(`${this.apiBase}/deploys/${t}/files${o}`, {
       method: "PUT",
       headers: { "Content-Type": "application/octet-stream", Authorization: `Bearer ${a}` },
       body: e
     });
-    if (!i.ok) throw r(`upload ${o}`, i.status);
+    if (!s.ok) throw i(`upload ${o}`, s.status);
   }
   async waitUntilReady(t, o) {
-    for (let e = 0; e < 600; e++) {
-      const a = await fetch(`${this.apiBase}/deploys/${t.deploy_id}`, {
+    const e = this.timeoutMs / this.pollIntervalMs;
+    for (let a = 0; a < e; a++) {
+      const s = await fetch(`${this.apiBase}/deploys/${t.deploy_id}`, {
         headers: { Authorization: `Bearer ${o}` }
       });
-      if (a.ok && (await a.json()).state === "ready") return;
-      await new Promise((i) => setTimeout(i, 1e3));
+      if (s.ok && (await s.json()).state === "ready") return;
+      await new Promise((n) => setTimeout(n, this.pollIntervalMs));
     }
-    throw new Error("Deploy did not become ready in time");
+    throw new d();
   }
 }
 export {
-  p as AnonymousDropClient,
-  r as apiError
+  y as AnonymousDropClient,
+  i as apiError
 };

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

@@ -0,0 +1,29 @@
+/**
+ * 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 declare 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 declare const DEFAULT_API_BASE = "https://api.netlify.com/api/v1";
+export declare const DEFAULT_POLL_INTERVAL_MS = 1000;
+export declare const DEFAULT_TIMEOUT_MS: number;
+export declare 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 declare const TOKEN_REUSE_MS: number;
+/**
+ * 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 declare const UPLOAD_RETRY_DELAYS_MS: readonly number[];

package/dist/drop-core/constants.js

@@ -0,0 +1,10 @@
+const _ = "/access-control/bb-api/api/v1", E = "https://api.netlify.com/api/v1", t = 1e3, A = 6e5, c = 5, o = 2e4, s = [1e3, 2e3, 3e3];
+export {
+  E as DEFAULT_API_BASE,
+  t as DEFAULT_POLL_INTERVAL_MS,
+  _ as DEFAULT_PROXY_BASE,
+  A as DEFAULT_TIMEOUT_MS,
+  c as MAX_CONCURRENT_UPLOADS,
+  o as TOKEN_REUSE_MS,
+  s as UPLOAD_RETRY_DELAYS_MS
+};

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

@@ -5,6 +5,8 @@ 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 {

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/errors.d.ts

@@ -6,6 +6,7 @@
  * deployed as a one-asset site (matches react-ui).
  */
 export declare class UnsupportedDropError extends Error {
+    readonly code = "unsupported-drop";
     constructor();
 }
 /**
@@ -17,10 +18,21 @@ export declare class UnsupportedDropError extends Error {
  * through login/signup and have them drop again.
  */
 export declare class NotAuthenticatedError extends Error {
+    readonly code = "not-authenticated";
     constructor(message?: string);
 }
+/**
+ * Whether an error is the pre-mutation "no session" signal, however it
+ * traveled. This package ships as both raw TypeScript (`./components`) and
+ * compiled dist (`./preact`, `./drop-core`), so two copies of the class can
+ * coexist in one app and defeat `instanceof` — the `code` brand is the
+ * copy-proof fallback. Control flow that decides whether an anonymous retry
+ * is safe must use this, never a bare `instanceof`.
+ */
+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,6 +41,7 @@ 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);
 }
@@ -40,10 +53,26 @@ export declare class BuildCreateError extends Error {
  */
 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`. Like a build failure,
+ * the API's `error_message` is the actionable part, so it travels on the error.
+ */
+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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@netlify/spark-ui",
   "description": "Assets, design tokens, components, and utilities",
-  "version": "1.31.0-alpha.4",
+  "version": "1.31.0-alpha.5",
   "type": "module",
   "main": "dist/components/preact/index.js",
   "types": "dist/components/preact/index.d.ts",

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

@@ -64,12 +64,11 @@ interface Props {
    */
   siteDashboardUrl?: (siteName: string) => string;
   /**
-   * Where to send a build-required drop (framework source, build command,
-   * functions) that can't be built here — no `getUploadToken`/`buildClient`, or a
-   * visitor who isn't logged in. Such projects can't deploy through the anonymous
-   * static drop API, so by default the user is redirected here — the app signup
-   * page with `next=/drop` — to build on the authenticated Drop page. Override to
-   * point at your own destination.
+   * The signup hand-off for a build-required drop that can't be built here (no
+   * session, or no build wiring). The drop is stashed on this origin first, so
+   * a flow that returns the visitor to this page deploys it automatically —
+   * see `resumeStashedBuilds`. Defaults to the app signup page with
+   * `next=/drop`.
    */
   buildSignupUrl?: string;
   /**
@@ -79,7 +78,7 @@ interface Props {
    * build-required drops build in place instead of being handed off to the app.
    * On netlify.com this reads `GET /access-control/generate-access-control-token`.
    * Resolving `null` means "no session": static drops fall back to the anonymous
-   * claim flow, build drops to `buildSignupUrl`.
+   * claim flow; build drops are stashed and handed to `buildSignupUrl`.
    * See [Logged-in visitors](#logged-in-visitors).
    */
   getUploadToken?: () => Promise<string | null>;