@netlify/spark-ui 1.31.0-alpha.7 → 1.31.0-alpha.8

package/dist/components/preact/DropZone/DropZone.js

@@ -160,6 +160,8 @@ function ne({
           return /* @__PURE__ */ e(o, { label: "Site’s live — taking you to claim it…" });
         case "dashboard":
           return /* @__PURE__ */ e(o, { label: "Site’s live — taking you to your new project…" });
+        default:
+          return null;
       }
     case "uploading": {
       const c = r.total ? Math.round(r.uploaded / r.total * 100) : 0;

package/dist/components/preact/DropZone/useDropDeploy.js

@@ -1,22 +1,22 @@
-import { d as O, A as S, y as nt } from "../../../chunks/hooks.module.DRcxknIz.js";
-import { humanizeDropError as rt, isNotAuthenticatedError as R } from "../../../drop-core/errors.js";
+import { d as R, A as _, y as nt } from "../../../chunks/hooks.module.DRcxknIz.js";
+import { humanizeDropError as rt, isNotAuthenticatedError as v } from "../../../drop-core/errors.js";
 import { DROPZONE_EVENTS as c } from "../../../drop-core/analytics.js";
 import { renameSingleNonIndexHtmlToIndex as at, getSingleNonIndexHtmlFileName as ot, hasMultipleHtmlFilesWithoutIndex as st } from "../../../drop-core/readFiles.js";
 import { detectBuild as dt } from "../../../drop-core/detectBuild.js";
-import { zipFiles as ut } from "../../../drop-core/zip.js";
-import { AnonymousDropClient as lt } from "../../../drop-core/client.js";
+import { zipFiles as lt } from "../../../drop-core/zip.js";
+import { AnonymousDropClient as ut } from "../../../drop-core/client.js";
 import { AuthenticatedDropClient as ct } from "../../../drop-core/authedDropClient.js";
 import { AuthenticatedBuildClient as mt } from "../../../drop-core/buildClient.js";
-import { deployZippedBuild as ft, deployFiles as v } from "../../../drop-core/deploy.js";
-import { hasDropStashMarker as gt, loadDropStash as ht, clearDropStash as y, saveDropStash as pt } from "../../../drop-core/buildStash.js";
-function I(u) {
-  switch (u.phase) {
+import { deployZippedBuild as ft, deployFiles as z } from "../../../drop-core/deploy.js";
+import { hasDropStashMarker as gt, loadDropStash as ht, clearDropStash as I, saveDropStash as pt } from "../../../drop-core/buildStash.js";
+function N(l) {
+  switch (l.phase) {
     case "zipping":
       return { kind: "zipping" };
     case "creating":
       return { kind: "creating" };
     case "uploading":
-      return { kind: "uploading", uploaded: u.uploaded ?? 0, total: u.total ?? 0 };
+      return { kind: "uploading", uploaded: l.uploaded ?? 0, total: l.total ?? 0 };
     case "building":
       return { kind: "building" };
     case "processing":
@@ -24,196 +24,201 @@ function I(u) {
       return { kind: "processing" };
   }
 }
-function wt(u) {
-  const m = ot(u);
-  return m ? `No index.html found — "${m}" won’t be served at the site root.` : st(u) ? "No index.html found — your site may not have a landing page." : null;
+function wt(l) {
+  const m = ot(l);
+  return m ? `No index.html found — "${m}" won’t be served at the site root.` : st(l) ? "No index.html found — your site may not have a landing page." : null;
 }
-function St(u, m) {
+function St(l, m) {
   try {
-    localStorage.setItem("drop-token", u), localStorage.setItem("dropSiteName", m);
+    localStorage.setItem("drop-token", l), localStorage.setItem("dropSiteName", m);
   } catch {
   }
 }
 function Ft({
-  apiBase: u,
+  apiBase: l,
   client: m,
-  claimUrl: z,
-  siteDashboardUrl: Y,
-  buildSignupUrl: H,
-  buildClient: W,
-  authenticatedDropClient: M,
-  getUploadToken: p,
-  proxyBase: N,
-  accountSlug: A,
-  buildDeployUrl: L,
-  waitForBuild: Z,
-  onBuildRequired: C,
-  onBuildSignupHandoff: F,
-  resumeStashedBuilds: $ = !0,
-  onDeploy: _,
+  claimUrl: Y,
+  siteDashboardUrl: H,
+  buildSignupUrl: W,
+  buildClient: M,
+  authenticatedDropClient: Z,
+  getUploadToken: w,
+  proxyBase: A,
+  accountSlug: L,
+  buildDeployUrl: C,
+  waitForBuild: $,
+  onBuildRequired: F,
+  onBuildSignupHandoff: P,
+  resumeStashedBuilds: q = !0,
+  onDeploy: k,
   onBuildDeploy: f,
   onError: g,
-  track: q
+  track: U
 }) {
-  const l = (n, i) => (
+  const u = (n, t) => (
     // The event interfaces carry no index signature, hence the cast to TrackFn's record.
-    q(n, i)
-  ), [k, a] = O({ kind: "idle" }), [U, b] = O(null), j = S(m ?? new lt(u)).current, w = S(
-    W ?? (p ? new mt({ proxyBase: N, getUploadToken: p, accountSlug: A }) : null)
-  ).current, D = S(
-    M ?? (p ? new ct({ proxyBase: N, getUploadToken: p, accountSlug: A }) : null)
-  ).current, J = k.kind !== "idle" && k.kind !== "error";
-  async function P(n, i) {
+    U(n, t)
+  ), [b, o] = R({ kind: "idle" }), [j, D] = R(null), J = _(m ?? new ut(l)).current, S = _(
+    M ?? (w ? new mt({ proxyBase: A, getUploadToken: w, accountSlug: L }) : null)
+  ).current, E = _(
+    Z ?? (w ? new ct({ proxyBase: A, getUploadToken: w, accountSlug: L }) : null)
+  ).current, Q = b.kind !== "idle" && b.kind !== "error";
+  async function x(n, t) {
     try {
-      const { site: e, build: r, buildSettings: o, url: t } = await ft(n, i, {
-        onProgress: (s) => a(I(s)),
-        waitForBuild: Z
+      const { site: i, build: r, buildSettings: s, url: a } = await ft(n, t, {
+        onProgress: (e) => o(N(e)),
+        waitForBuild: $
       });
       return {
-        url: t,
-        siteName: e.name,
-        siteId: e.id,
+        url: a,
+        siteName: i.name,
+        siteId: i.id,
         buildId: r.id,
         deployId: r.deploy_id,
-        buildSettings: o
+        buildSettings: s
       };
-    } catch (e) {
-      if (R(e)) return null;
-      throw e;
+    } catch (i) {
+      if (v(i)) return null;
+      throw i;
     }
   }
-  async function Q(n, i, e) {
-    b(null), a({ kind: "reading" });
-    const r = e.length ? { file_types: e } : {}, o = (t, s, d) => {
-      a({ kind: "error", message: t }), l(c.DEPLOY_FAILED, { method: i, reason: s, ...r, ...d }), g == null || g({ message: t, reason: s });
+  async function T(n, t, i) {
+    D(null), o({ kind: "reading" });
+    const r = i.length ? { file_types: i } : {}, s = (e, d, h) => {
+      o({ kind: "error", message: e }), u(c.DEPLOY_FAILED, { method: t, reason: d, ...r, ...h }), g == null || g({ message: e, reason: d });
     };
+    let a;
     try {
-      const t = at(await n());
-      if (!t.length) {
-        o("No files found to deploy.", "No files found to deploy.", { file_count: 0 });
+      const e = at(await n());
+      if (a = e.length, !e.length) {
+        s("No files found to deploy.", "No files found to deploy.", { file_count: 0 });
         return;
       }
-      i === "drag" && l(c.FILES_DROPPED, {
-        method: i,
-        file_count: t.length,
+      t === "drag" && u(c.FILES_DROPPED, {
+        method: t,
+        file_count: e.length,
         ...r
       });
-      const s = { source: i, fileCount: t.length, typeProps: r }, d = dt(t);
-      d.buildRequired ? await T(t, d, s) : await G(t, s);
-    } catch (t) {
-      const s = t instanceof Error ? t.message : String(t);
-      o(rt(t), s);
+      const d = { source: t, fileCount: e.length, typeProps: r }, h = dt(e);
+      h.buildRequired ? await V(e, h, d) : await K(e, d);
+    } catch (e) {
+      const d = e instanceof Error ? e.message : String(e);
+      s(
+        rt(e),
+        d,
+        a !== void 0 ? { file_count: a } : void 0
+      );
     }
   }
-  async function T(n, i, { source: e, fileCount: r, typeProps: o }) {
-    if (l(c.BUILD_REQUIRED, {
-      method: e,
-      reason: i.reason,
+  async function V(n, t, { source: i, fileCount: r, typeProps: s }) {
+    if (u(c.BUILD_REQUIRED, {
+      method: i,
+      reason: t.reason,
       file_count: r,
-      ...o
-    }), C) {
-      a({ kind: "idle" }), C(i);
+      ...s
+    }), F) {
+      o({ kind: "idle" }), F(t);
       return;
     }
-    let t = !1;
-    if (w) {
-      a({ kind: "zipping" });
-      const s = await ut(n), d = await P(w, s);
+    let a = !1;
+    if (S) {
+      o({ kind: "zipping" });
+      const e = await lt(n), d = await x(S, e);
       if (d) {
-        a({ kind: "redirecting", target: "build" }), l(c.BUILD_DEPLOY_SUCCEEDED, {
-          method: e,
-          reason: i.reason,
+        o({ kind: "redirecting", target: "build" }), u(c.BUILD_DEPLOY_SUCCEEDED, {
+          method: i,
+          reason: t.reason,
           site_name: d.siteName,
           file_count: r,
           ...d.buildSettings ? { framework: d.buildSettings.framework } : {},
-          ...o
-        }), f == null || f(d), window.location.assign(L(d));
+          ...s
+        }), f == null || f(d), window.location.assign(C(d));
         return;
       }
-      t = await pt(s.file, s.buildSettings), t && l(c.PROJECT_STASHED, {
-        method: e,
-        reason: i.reason,
+      a = await pt(e.file, e.buildSettings), a && u(c.PROJECT_STASHED, {
+        method: i,
+        reason: t.reason,
         file_count: r,
-        ...o
+        ...s
       });
     }
-    if (t || l(c.DEPLOY_FAILED, {
-      method: e,
+    if (a || u(c.DEPLOY_FAILED, {
+      method: i,
       reason: "anonymous_build_not_supported",
       file_count: r,
-      ...o
-    }), F) {
-      a({ kind: "idle" }), F({ stashed: t, detection: i });
+      ...s
+    }), P) {
+      o({ kind: "idle" }), P({ stashed: a, detection: t });
       return;
     }
-    a({ kind: "redirecting", target: "signup" }), window.location.assign(H);
+    o({ kind: "redirecting", target: "signup" }), window.location.assign(W);
   }
-  async function V(n, i) {
+  async function G(n, t) {
     try {
-      return await v(n, i, {
-        onProgress: (e) => a(I(e))
+      return await z(n, t, {
+        onProgress: (i) => o(N(i))
       });
-    } catch (e) {
-      if (R(e)) return null;
-      throw e;
+    } catch (i) {
+      if (v(i)) return null;
+      throw i;
     }
   }
-  async function G(n, { source: i, fileCount: e, typeProps: r }) {
-    b(wt(n));
-    const o = D ? await V(D, n) : null, t = o !== null, s = D !== null && !t, d = o ?? await v(j, n, {
-      onProgress: (et) => a(I(et))
-    }), { url: it, token: E, deploy: h } = d;
-    t || St(E, h.subdomain), a({ kind: "redirecting", target: t ? "dashboard" : "claim" }), l(c.DEPLOY_SUCCEEDED, {
-      method: i,
-      site_name: h.subdomain,
-      file_count: e,
-      authenticated: t,
-      ...s ? { auth_fallback: !0 } : {},
+  async function K(n, { source: t, fileCount: i, typeProps: r }) {
+    D(wt(n));
+    const s = E ? await G(E, n) : null, a = s !== null, e = E !== null && !a, d = s ?? await z(J, n, {
+      onProgress: (et) => o(N(et))
+    }), { url: h, token: y, deploy: p } = d;
+    a || St(y, p.subdomain), o({ kind: "redirecting", target: a ? "dashboard" : "claim" }), u(c.DEPLOY_SUCCEEDED, {
+      method: t,
+      site_name: p.subdomain,
+      file_count: i,
+      authenticated: a,
+      ...e ? { auth_fallback: !0 } : {},
       ...r
-    }), _ == null || _({
-      url: it,
-      ...t ? {} : { token: E },
-      siteName: h.subdomain,
-      siteId: h.id,
-      authenticated: t
-    }), K(t, h.subdomain, E);
+    }), k == null || k({
+      url: h,
+      ...a ? {} : { token: y },
+      siteName: p.subdomain,
+      siteId: p.id,
+      authenticated: a
+    }), X(a, p.subdomain, y);
   }
-  function K(n, i, e) {
-    n ? window.location.assign(Y(i)) : window.location.assign(`${z(i)}#drop_token=${e}`);
+  function X(n, t, i) {
+    n ? window.location.assign(H(t)) : window.location.assign(`${Y(t)}#drop_token=${i}`);
   }
-  async function X(n) {
-    const i = await ht();
-    if (!i) {
-      await y();
+  async function B(n) {
+    const t = await ht();
+    if (!t) {
+      await I();
       return;
     }
-    l(c.RESUMED, {}), a({ kind: "creating" });
-    const e = { file: i.zipFile, buildSettings: i.buildSettings };
+    o({ kind: "creating" });
+    const i = { file: t.zipFile, buildSettings: t.buildSettings };
     let r;
     try {
-      r = await P(n, e);
-    } catch (o) {
-      await y(), B(o instanceof Error ? o.message : String(o));
+      r = await x(n, i);
+    } catch (s) {
+      await I(), tt(s instanceof Error ? s.message : String(s));
       return;
     }
     if (!r) {
-      a({ kind: "idle" });
+      o({ kind: "idle" });
       return;
     }
-    await y(), a({ kind: "redirecting", target: "build" }), f == null || f(r), window.location.assign(L(r));
+    u(c.RESUMED, {}), await I(), o({ kind: "redirecting", target: "build" }), f == null || f(r), window.location.assign(C(r));
   }
-  function B(n) {
-    const i = "We couldn’t automatically deploy your project. Drop it again to publish it.";
-    a({ kind: "error", message: i }), l(c.DEPLOY_FAILED, { reason: "resume_failed" }), g == null || g({ message: i, reason: n });
+  function tt(n) {
+    const t = "We couldn’t automatically deploy your project. Drop it again to publish it.";
+    o({ kind: "error", message: t }), u(c.DEPLOY_FAILED, { reason: "resume_failed" }), g == null || g({ message: t, reason: n });
   }
-  const x = S(!1);
+  const O = _(!1);
   nt(() => {
-    x.current || !$ || !w || !gt() || (x.current = !0, X(w));
+    O.current || !q || !S || !gt() || (O.current = !0, B(S));
   }, []);
-  function tt() {
-    b(null), a({ kind: "idle" });
+  function it() {
+    D(null), o({ kind: "idle" });
   }
-  return { status: k, warning: U, busy: J, deploy: Q, reset: tt };
+  return { status: b, warning: j, busy: Q, deploy: T, reset: it };
 }
 export {
   Ft as useDropDeploy

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

@@ -1,4 +1,6 @@
 import { BuildSite } from './types';
+import { SettledDeploy } from './pollDeploy';
+export type { SettledDeploy } from './pollDeploy';
 /**
  * Transport shared by both authenticated clients: JSON rides the consumer's
  * access-control rewrite on the session cookie. Uploads are each client's own
@@ -10,19 +12,9 @@ import { BuildSite } from './types';
  * fallback is still safe, hence NotAuthenticatedError.
  */
 export declare function createSiteInAccount(proxyBase: string, accountSlug?: string): Promise<BuildSite>;
-/** How a watched deploy ended. `errorMessage` is the API's own explanation, when it gave one. */
-export type SettledDeploy = {
-    outcome: 'ready';
-} | {
-    outcome: 'failed';
-    errorMessage?: string;
-} | {
-    outcome: 'timed-out';
-};
 /**
- * Polls the deploy on the session cookie and reports the terminal outcome —
- * callers map it onto their own error vocabulary. Non-ok reads are skipped,
- * not fatal: a proxy hiccup shouldn't kill a progressing deploy.
+ * Polls a deploy over the session-cookie proxy — the shared `pollUntilSettled`
+ * loop with the cookie transport bound in. A non-ok read is skipped, not fatal.
  */
 export declare function pollDeployUntilSettled(options: {
     proxyBase: string;

package/dist/drop-core/authedApi.js

@@ -1,30 +1,29 @@
-import { NotAuthenticatedError as d, SiteCreateError as l } from "./errors.js";
-async function f(r, o) {
-  const s = o ? `/${o}/sites` : "/sites", e = await fetch(`${r}${s}`, {
+import { NotAuthenticatedError as a, SiteCreateError as l } from "./errors.js";
+import { pollUntilSettled as c } from "./pollDeploy.js";
+async function u(o, e) {
+  const n = e ? `/${e}/sites` : "/sites", t = await fetch(`${o}${n}`, {
     method: "POST",
     credentials: "include",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ created_via: "drop" })
   });
-  if (e.status === 401 || e.status === 403) throw new d();
-  if (!e.ok) throw new l(e.status);
-  return e.json();
+  if (t.status === 401 || t.status === 403) throw new a();
+  if (!t.ok) throw new l(t.status);
+  return t.json();
 }
-const u = /* @__PURE__ */ new Set(["ready", "error", "rejected"]);
-async function y(r) {
-  const { proxyBase: o, deployId: s, pollIntervalMs: e, timeoutMs: i } = r, c = i / e;
-  for (let n = 0; n < c; n++) {
-    const a = await fetch(`${o}/deploys/${s}`, { credentials: "include" });
-    if (a.ok) {
-      const t = await a.json();
-      if (t.state && u.has(t.state))
-        return t.state === "ready" ? { outcome: "ready" } : { outcome: "failed", errorMessage: t.error_message };
+function f(o) {
+  const { proxyBase: e, deployId: n, pollIntervalMs: t, timeoutMs: s } = o;
+  return c({
+    deployId: n,
+    pollIntervalMs: t,
+    timeoutMs: s,
+    readState: async (i) => {
+      const r = await fetch(`${e}/deploys/${i}`, { credentials: "include" });
+      return r.ok ? r.json() : null;
     }
-    await new Promise((t) => setTimeout(t, e));
-  }
-  return { outcome: "timed-out" };
+  });
 }
 export {
-  f as createSiteInAccount,
-  y as pollDeployUntilSettled
+  u as createSiteInAccount,
+  f as pollDeployUntilSettled
 };

package/dist/drop-core/client.js

@@ -1,15 +1,16 @@
-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 });
+import { DEFAULT_API_BASE as n, DEFAULT_POLL_INTERVAL_MS as l, DEFAULT_TIMEOUT_MS as p } from "./constants.js";
+import { DeployFailedError as d, DeployTimeoutError as c } from "./errors.js";
+import { pollUntilSettled as h } from "./pollDeploy.js";
+function a(i, t) {
+  return Object.assign(new Error(`${i} failed: ${t}`), { status: t });
 }
-class y {
-  constructor(t = p, o = l, e = h) {
+class m {
+  constructor(t = n, o = l, e = p) {
     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 i("drop/token", t.status);
+    if (!t.ok) throw a("drop/token", t.status);
     return (await t.json()).token;
   }
   async createDeploy(t, o) {
@@ -18,30 +19,37 @@ class y {
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ files: t, token: o })
     });
-    if (!e.ok) throw i("drop", e.status);
+    if (!e.ok) throw a("drop", e.status);
     return e.json();
   }
-  async uploadFile(t, o, e, a) {
-    const s = await fetch(`${this.apiBase}/deploys/${t}/files${o}`, {
+  async uploadFile(t, o, e, s) {
+    const r = await fetch(`${this.apiBase}/deploys/${t}/files${o}`, {
       method: "PUT",
-      headers: { "Content-Type": "application/octet-stream", Authorization: `Bearer ${a}` },
+      headers: { "Content-Type": "application/octet-stream", Authorization: `Bearer ${s}` },
       body: e
     });
-    if (!s.ok) throw i(`upload ${o}`, s.status);
+    if (!r.ok) throw a(`upload ${o}`, r.status);
   }
   async waitUntilReady(t, o) {
-    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 (s.ok && (await s.json()).state === "ready") return;
-      await new Promise((n) => setTimeout(n, this.pollIntervalMs));
-    }
-    throw new d();
+    const e = await h({
+      deployId: t.deploy_id,
+      pollIntervalMs: this.pollIntervalMs,
+      timeoutMs: this.timeoutMs,
+      // `/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!.
+      readState: async (s) => {
+        const r = await fetch(`${this.apiBase}/deploys/${s}`, {
+          headers: { Authorization: `Bearer ${o}` }
+        });
+        return r.ok ? r.json() : null;
+      }
+    });
+    if (e.outcome !== "ready")
+      throw e.outcome === "failed" ? new d(e.errorMessage) : new c();
   }
 }
 export {
-  y as AnonymousDropClient,
-  i as apiError
+  m as AnonymousDropClient,
+  a as apiError
 };

package/dist/drop-core/client.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,31 @@
+/**
+ * The single deploy poller both drop clients share. The loop and its
+ * terminal-state policy live here once; transport (cookie proxy vs bearer) is
+ * injected via `readState`, so the anonymous and authenticated paths can't
+ * drift on what "done" means.
+ */
+/** How a watched deploy ended. `errorMessage` is the API's own explanation, when it gave one. */
+export type SettledDeploy = {
+    outcome: 'ready';
+} | {
+    outcome: 'failed';
+    errorMessage?: string;
+} | {
+    outcome: 'timed-out';
+};
+/** The slice of a deploy record the poller reads; `null` = a read that failed and should be skipped. */
+export interface DeployState {
+    state?: string;
+    error_message?: string;
+}
+/**
+ * Poll until the deploy reaches a terminal state or the timeout elapses.
+ * A `null` read is skipped, not fatal — a transient hiccup shouldn't kill a
+ * progressing deploy. Callers map the outcome onto their own error vocabulary.
+ */
+export declare function pollUntilSettled(options: {
+    deployId: string;
+    pollIntervalMs: number;
+    timeoutMs: number;
+    readState: (deployId: string) => Promise<DeployState | null>;
+}): Promise<SettledDeploy>;

package/dist/drop-core/pollDeploy.js

@@ -0,0 +1,14 @@
+const c = /* @__PURE__ */ new Set(["ready", "error", "rejected"]);
+async function l(r) {
+  const { deployId: a, pollIntervalMs: t, timeoutMs: s, readState: n } = r, i = s / t;
+  for (let o = 0; o < i; o++) {
+    const e = await n(a);
+    if (e != null && e.state && c.has(e.state))
+      return e.state === "ready" ? { outcome: "ready" } : { outcome: "failed", errorMessage: e.error_message };
+    await new Promise((d) => setTimeout(d, t));
+  }
+  return { outcome: "timed-out" };
+}
+export {
+  l as pollUntilSettled
+};

package/dist/drop-core/pollDeploy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

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

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

@@ -309,6 +309,8 @@ function StatusView({
           return <Spinner label="Site’s live — taking you to claim it…" />;
         case 'dashboard':
           return <Spinner label="Site’s live — taking you to your new project…" />;
+        default:
+          return null;
       }
 
     case 'uploading': {

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

@@ -346,6 +346,9 @@ describe('stash resume on mount', () => {
     expect(clearDropStash).not.toHaveBeenCalled(); // preserved for the next authenticated visit
     expect(harness.api.status.kind).toBe('idle');
     expect(harness.errors).toHaveLength(0);
+    // Nothing deployed, so no resume was counted — otherwise every logged-out
+    // reload with a stash would inflate the metric.
+    expect(harness.events.map(e => e.event)).not.toContain(DROPZONE_EVENTS.RESUMED);
   });
 
   it('surfaces a real resume failure with re-drop copy, stash consumed', async () => {

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

@@ -268,11 +268,15 @@ export function useDropDeploy({
       onError?.({ message, reason });
     };
 
+    // Set once the file set is read, so a later throw still reports file_count.
+    let knownFileCount: number | undefined;
+
     try {
       // Rename a lone non-index HTML file so it is served at the site root.
       // Warnings are computed on the renamed set, so the fixable single-file
       // case no longer warns and only the multi-HTML case does.
       const files = renameSingleNonIndexHtmlToIndex(await read());
+      knownFileCount = files.length;
       if (!files.length) {
         fail('No files found to deploy.', 'No files found to deploy.', { file_count: 0 });
         return;
@@ -297,7 +301,11 @@ export function useDropDeploy({
       }
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
-      fail(humanizeDropError(err), reason);
+      fail(
+        humanizeDropError(err),
+        reason,
+        knownFileCount !== undefined ? { file_count: knownFileCount } : undefined
+      );
     }
   }
 
@@ -481,7 +489,6 @@ export function useDropDeploy({
       return;
     }
 
-    emit(DROPZONE_EVENTS.RESUMED, {});
     setStatus({ kind: 'creating' });
 
     const archive: ZipResult = { file: stash.zipFile, buildSettings: stash.buildSettings };
@@ -496,11 +503,13 @@ export function useDropDeploy({
 
     if (!built) {
       // Still no session — the visitor came back logged out. Keep the stash for
-      // their next authenticated visit.
+      // their next authenticated visit. No RESUMED event: nothing deployed.
       setStatus({ kind: 'idle' });
       return;
     }
 
+    // Only now is a resume real — a logged-out attempt above never counts.
+    emit(DROPZONE_EVENTS.RESUMED, {});
     await clearDropStash();
     setStatus({ kind: 'redirecting', target: 'build' });
     onBuildDeploy?.(built);

package/packages/drop-core/authedApi.ts

@@ -1,5 +1,8 @@
 import type { BuildSite } from './types';
 import { NotAuthenticatedError, SiteCreateError } from './errors';
+import { pollUntilSettled, type SettledDeploy } from './pollDeploy';
+
+export type { SettledDeploy } from './pollDeploy';
 
 /**
  * Transport shared by both authenticated clients: JSON rides the consumer's
@@ -28,41 +31,24 @@ export async function createSiteInAccount(
   return res.json();
 }
 
-/** How a watched deploy ended. `errorMessage` is the API's own explanation, when it gave one. */
-export type SettledDeploy =
-  { outcome: 'ready' } | { outcome: 'failed'; errorMessage?: string } | { outcome: 'timed-out' };
-
-/** Deploy states that end the wait — `ready` succeeds, the rest are failures. */
-const TERMINAL_STATES = new Set(['ready', 'error', 'rejected']);
-
-interface DeployState {
-  state?: string;
-  error_message?: string;
-}
-
 /**
- * Polls the deploy on the session cookie and reports the terminal outcome —
- * callers map it onto their own error vocabulary. Non-ok reads are skipped,
- * not fatal: a proxy hiccup shouldn't kill a progressing deploy.
+ * Polls a deploy over the session-cookie proxy — the shared `pollUntilSettled`
+ * loop with the cookie transport bound in. A non-ok read is skipped, not fatal.
  */
-export async function pollDeployUntilSettled(options: {
+export function pollDeployUntilSettled(options: {
   proxyBase: string;
   deployId: string;
   pollIntervalMs: number;
   timeoutMs: number;
 }): Promise<SettledDeploy> {
   const { proxyBase, deployId, pollIntervalMs, timeoutMs } = options;
-  const deadline = timeoutMs / pollIntervalMs;
-  for (let i = 0; i < deadline; i++) {
-    const res = await fetch(`${proxyBase}/deploys/${deployId}`, { credentials: 'include' });
-    if (res.ok) {
-      const deploy: DeployState = await res.json();
-      if (deploy.state && TERMINAL_STATES.has(deploy.state)) {
-        if (deploy.state === 'ready') return { outcome: 'ready' };
-        return { outcome: 'failed', errorMessage: deploy.error_message };
-      }
-    }
-    await new Promise(r => setTimeout(r, pollIntervalMs));
-  }
-  return { outcome: 'timed-out' };
+  return pollUntilSettled({
+    deployId,
+    pollIntervalMs,
+    timeoutMs,
+    readState: async id => {
+      const res = await fetch(`${proxyBase}/deploys/${id}`, { credentials: 'include' });
+      return res.ok ? res.json() : null;
+    },
+  });
 }

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

@@ -0,0 +1,29 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { AnonymousDropClient } from './client';
+import { DeployFailedError } from './errors';
+import type { DropResponse } from './types';
+
+const deploy: DropResponse = { id: 'site', deploy_id: 'd', subdomain: 'x', required: [] };
+const client = () => new AnonymousDropClient('https://api', 1, 50);
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe('AnonymousDropClient.waitUntilReady', () => {
+  it('resolves once the deploy is ready', async () => {
+    vi.stubGlobal('fetch', async () => ({ ok: true, json: async () => ({ state: 'ready' }) }));
+    await expect(client().waitUntilReady(deploy, 'tok')).resolves.toBeUndefined();
+  });
+
+  // Regression: a failed anonymous deploy used to poll to the full timeout.
+  it('fails fast on a failed deploy instead of timing out', async () => {
+    vi.stubGlobal('fetch', async () => ({
+      ok: true,
+      json: async () => ({ state: 'error', error_message: 'nope' }),
+    }));
+    const err = await client()
+      .waitUntilReady(deploy, 'tok')
+      .catch(e => e);
+    expect(err).toBeInstanceOf(DeployFailedError);
+    expect(err.reason).toBe('nope');
+  });
+});

package/packages/drop-core/client.ts

@@ -3,7 +3,8 @@
  * interface, so `deployFiles` runs the same pipeline anonymous or authenticated.
  */
 import { DEFAULT_API_BASE, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS } from './constants';
-import { DeployTimeoutError } from './errors';
+import { DeployFailedError, DeployTimeoutError } from './errors';
+import { pollUntilSettled } from './pollDeploy';
 import type { DropResponse, Digest } from './types';
 
 /** A normal Error with the response's HTTP status attached, so callers can branch on it directly. */
@@ -61,17 +62,24 @@ export class AnonymousDropClient implements DropClient {
   }
 
   async waitUntilReady(deploy: DropResponse, token: string): Promise<void> {
-    // `/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!.
-    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, this.pollIntervalMs));
-    }
+    const settled = await pollUntilSettled({
+      deployId: deploy.deploy_id,
+      pollIntervalMs: this.pollIntervalMs,
+      timeoutMs: this.timeoutMs,
+      // `/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!.
+      readState: async id => {
+        const res = await fetch(`${this.apiBase}/deploys/${id}`, {
+          headers: { Authorization: `Bearer ${token}` },
+        });
+        return res.ok ? res.json() : null;
+      },
+    });
+    if (settled.outcome === 'ready') return;
+    // A failed deploy now surfaces immediately instead of waiting out the full
+    // timeout, matching the authenticated path.
+    if (settled.outcome === 'failed') throw new DeployFailedError(settled.errorMessage);
     throw new DeployTimeoutError();
   }
 }

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

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { pollUntilSettled } from './pollDeploy';
+
+const base = { deployId: 'd', pollIntervalMs: 1, timeoutMs: 50 };
+
+describe('pollUntilSettled', () => {
+  it('resolves ready when the deploy reaches ready', async () => {
+    const settled = await pollUntilSettled({ ...base, readState: async () => ({ state: 'ready' }) });
+    expect(settled).toEqual({ outcome: 'ready' });
+  });
+
+  it('reports failure with the API message on error/rejected', async () => {
+    for (const state of ['error', 'rejected']) {
+      const settled = await pollUntilSettled({
+        ...base,
+        readState: async () => ({ state, error_message: 'boom' }),
+      });
+      expect(settled).toEqual({ outcome: 'failed', errorMessage: 'boom' });
+    }
+  });
+
+  it('times out when the deploy never settles (does not hang on failure states either)', async () => {
+    const settled = await pollUntilSettled({
+      ...base,
+      timeoutMs: 3,
+      readState: async () => ({ state: 'building' }),
+    });
+    expect(settled).toEqual({ outcome: 'timed-out' });
+  });
+
+  it('skips a null read without settling, then resolves', async () => {
+    let calls = 0;
+    const settled = await pollUntilSettled({
+      ...base,
+      readState: async () => (++calls < 3 ? null : { state: 'ready' }),
+    });
+    expect(settled).toEqual({ outcome: 'ready' });
+    expect(calls).toBeGreaterThanOrEqual(3);
+  });
+
+  it('waits through non-terminal states then settles on the terminal one', async () => {
+    const states = ['uploading', 'processing', 'ready'];
+    let i = 0;
+    const settled = await pollUntilSettled({
+      ...base,
+      readState: async () => ({ state: states[Math.min(i++, states.length - 1)] }),
+    });
+    expect(settled).toEqual({ outcome: 'ready' });
+  });
+});

package/packages/drop-core/pollDeploy.ts

@@ -0,0 +1,46 @@
+/**
+ * The single deploy poller both drop clients share. The loop and its
+ * terminal-state policy live here once; transport (cookie proxy vs bearer) is
+ * injected via `readState`, so the anonymous and authenticated paths can't
+ * drift on what "done" means.
+ */
+
+/** How a watched deploy ended. `errorMessage` is the API's own explanation, when it gave one. */
+export type SettledDeploy =
+  | { outcome: 'ready' }
+  | { outcome: 'failed'; errorMessage?: string }
+  | { outcome: 'timed-out' };
+
+/** The slice of a deploy record the poller reads; `null` = a read that failed and should be skipped. */
+export interface DeployState {
+  state?: string;
+  error_message?: string;
+}
+
+/** `ready` succeeds; `error`/`rejected` are failures; anything else keeps waiting. */
+const TERMINAL_STATES = new Set(['ready', 'error', 'rejected']);
+
+/**
+ * Poll until the deploy reaches a terminal state or the timeout elapses.
+ * A `null` read is skipped, not fatal — a transient hiccup shouldn't kill a
+ * progressing deploy. Callers map the outcome onto their own error vocabulary.
+ */
+export async function pollUntilSettled(options: {
+  deployId: string;
+  pollIntervalMs: number;
+  timeoutMs: number;
+  readState: (deployId: string) => Promise<DeployState | null>;
+}): Promise<SettledDeploy> {
+  const { deployId, pollIntervalMs, timeoutMs, readState } = options;
+  const deadline = timeoutMs / pollIntervalMs;
+  for (let i = 0; i < deadline; i++) {
+    const deploy = await readState(deployId);
+    if (deploy?.state && TERMINAL_STATES.has(deploy.state)) {
+      return deploy.state === 'ready'
+        ? { outcome: 'ready' }
+        : { outcome: 'failed', errorMessage: deploy.error_message };
+    }
+    await new Promise(r => setTimeout(r, pollIntervalMs));
+  }
+  return { outcome: 'timed-out' };
+}