@netlify/spark-ui 1.31.0-alpha.6 → 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,5 +1,5 @@
-import { d as R, A as S, y as nt } from "../../../chunks/hooks.module.DRcxknIz.js";
-import { humanizeDropError as rt, isNotAuthenticatedError as O } 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";
@@ -7,9 +7,9 @@ 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 E, saveDropStash as pt } from "../../../drop-core/buildStash.js";
-function I(l) {
+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" };
@@ -34,63 +34,64 @@ function St(l, m) {
   } catch {
   }
 }
-function Pt({
+function Ft({
   apiBase: l,
   client: m,
-  claimUrl: z,
+  claimUrl: Y,
   siteDashboardUrl: H,
   buildSignupUrl: W,
-  buildClient: Y,
-  authenticatedDropClient: M,
-  getUploadToken: p,
-  proxyBase: N,
-  accountSlug: A,
+  buildClient: M,
+  authenticatedDropClient: Z,
+  getUploadToken: w,
+  proxyBase: A,
+  accountSlug: L,
   buildDeployUrl: C,
-  waitForBuild: Z,
-  onBuildRequired: L,
+  waitForBuild: $,
+  onBuildRequired: F,
   onBuildSignupHandoff: P,
-  resumeStashedBuilds: $ = !0,
+  resumeStashedBuilds: q = !0,
   onDeploy: k,
   onBuildDeploy: f,
   onError: g,
-  track: q
+  track: U
 }) {
   const u = (n, t) => (
     // The event interfaces carry no index signature, hence the cast to TrackFn's record.
-    q(n, t)
-  ), [b, a] = R({ kind: "idle" }), [U, _] = R(null), j = S(m ?? new ut(l)).current, w = S(
-    Y ?? (p ? new mt({ proxyBase: N, getUploadToken: p, accountSlug: A }) : null)
-  ).current, y = S(
-    M ?? (p ? new ct({ proxyBase: N, getUploadToken: p, accountSlug: A }) : null)
-  ).current, J = b.kind !== "idle" && b.kind !== "error";
+    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: i, build: r, buildSettings: o, url: e } = await ft(n, t, {
-        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: e,
+        url: a,
         siteName: i.name,
         siteId: i.id,
         buildId: r.id,
         deployId: r.deploy_id,
-        buildSettings: o
+        buildSettings: s
       };
     } catch (i) {
-      if (O(i)) return null;
+      if (v(i)) return null;
       throw i;
     }
   }
-  async function Q(n, t, i) {
-    _(null), a({ kind: "reading" });
-    const r = i.length ? { file_types: i } : {}, o = (e, s, d) => {
-      a({ kind: "error", message: e }), u(c.DEPLOY_FAILED, { method: t, reason: s, ...r, ...d }), g == null || g({ message: e, 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 e = at(await n());
-      if (!e.length) {
-        o("No files found to deploy.", "No files found to deploy.", { file_count: 0 });
+      if (a = e.length, !e.length) {
+        s("No files found to deploy.", "No files found to deploy.", { file_count: 0 });
         return;
       }
       t === "drag" && u(c.FILES_DROPPED, {
@@ -98,118 +99,127 @@ function Pt({
         file_count: e.length,
         ...r
       });
-      const s = { source: t, fileCount: e.length, typeProps: r }, d = dt(e);
-      d.buildRequired ? await T(e, d, s) : await G(e, 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 s = e instanceof Error ? e.message : String(e);
-      o(rt(e), s);
+      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, t, { source: i, fileCount: r, typeProps: o }) {
+  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
-    }), L) {
-      a({ kind: "idle" }), L(t);
+      ...s
+    }), F) {
+      o({ kind: "idle" }), F(t);
       return;
     }
-    let e = !1;
-    if (w) {
-      a({ kind: "zipping" });
-      const s = await lt(n), d = await x(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" }), u(c.BUILD_DEPLOY_SUCCEEDED, {
+        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
+          ...s
         }), f == null || f(d), window.location.assign(C(d));
         return;
       }
-      e = await pt(s.file, s.buildSettings), e && u(c.PROJECT_STASHED, {
+      a = await pt(e.file, e.buildSettings), a && u(c.PROJECT_STASHED, {
         method: i,
         reason: t.reason,
         file_count: r,
-        ...o
+        ...s
       });
     }
-    if (P) {
-      a({ kind: "idle" }), P({ stashed: e, detection: t });
+    if (a || u(c.DEPLOY_FAILED, {
+      method: i,
+      reason: "anonymous_build_not_supported",
+      file_count: r,
+      ...s
+    }), P) {
+      o({ kind: "idle" }), P({ stashed: a, detection: t });
       return;
     }
-    a({ kind: "redirecting", target: "signup" }), window.location.assign(W);
+    o({ kind: "redirecting", target: "signup" }), window.location.assign(W);
   }
-  async function V(n, t) {
+  async function G(n, t) {
     try {
-      return await v(n, t, {
-        onProgress: (i) => a(I(i))
+      return await z(n, t, {
+        onProgress: (i) => o(N(i))
       });
     } catch (i) {
-      if (O(i)) return null;
+      if (v(i)) return null;
       throw i;
     }
   }
-  async function G(n, { source: t, fileCount: i, typeProps: r }) {
-    _(wt(n));
-    const o = y ? await V(y, n) : null, e = o !== null, s = y !== null && !e, d = o ?? await v(j, n, {
-      onProgress: (it) => a(I(it))
-    }), { url: et, token: D, deploy: h } = d;
-    e || St(D, h.subdomain), a({ kind: "redirecting", target: e ? "dashboard" : "claim" }), u(c.DEPLOY_SUCCEEDED, {
+  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: h.subdomain,
+      site_name: p.subdomain,
       file_count: i,
-      authenticated: e,
-      ...s ? { auth_fallback: !0 } : {},
+      authenticated: a,
+      ...e ? { auth_fallback: !0 } : {},
       ...r
     }), k == null || k({
-      url: et,
-      ...e ? {} : { token: D },
-      siteName: h.subdomain,
-      siteId: h.id,
-      authenticated: e
-    }), K(e, h.subdomain, D);
+      url: h,
+      ...a ? {} : { token: y },
+      siteName: p.subdomain,
+      siteId: p.id,
+      authenticated: a
+    }), X(a, p.subdomain, y);
   }
-  function K(n, t, i) {
-    n ? window.location.assign(H(t)) : window.location.assign(`${z(t)}#drop_token=${i}`);
+  function X(n, t, i) {
+    n ? window.location.assign(H(t)) : window.location.assign(`${Y(t)}#drop_token=${i}`);
   }
-  async function X(n) {
+  async function B(n) {
     const t = await ht();
     if (!t) {
-      await E();
+      await I();
       return;
     }
-    u(c.RESUMED, {}), a({ kind: "creating" });
+    o({ kind: "creating" });
     const i = { file: t.zipFile, buildSettings: t.buildSettings };
     let r;
     try {
       r = await x(n, i);
-    } catch (o) {
-      await E(), B(o instanceof Error ? o.message : String(o));
+    } catch (s) {
+      await I(), tt(s instanceof Error ? s.message : String(s));
       return;
     }
     if (!r) {
-      a({ kind: "idle" });
+      o({ kind: "idle" });
       return;
     }
-    await E(), a({ kind: "redirecting", target: "build" }), f == null || f(r), window.location.assign(C(r));
+    u(c.RESUMED, {}), await I(), o({ kind: "redirecting", target: "build" }), f == null || f(r), window.location.assign(C(r));
   }
-  function B(n) {
+  function tt(n) {
     const t = "We couldn’t automatically deploy your project. Drop it again to publish it.";
-    a({ kind: "error", message: t }), u(c.DEPLOY_FAILED, { reason: "resume_failed" }), g == null || g({ message: t, reason: n });
+    o({ kind: "error", message: t }), u(c.DEPLOY_FAILED, { reason: "resume_failed" }), g == null || g({ message: t, reason: n });
   }
-  const F = S(!1);
+  const O = _(!1);
   nt(() => {
-    F.current || !$ || !w || !gt() || (F.current = !0, X(w));
+    O.current || !q || !S || !gt() || (O.current = !0, B(S));
   }, []);
-  function tt() {
-    _(null), a({ kind: "idle" });
+  function it() {
+    D(null), o({ kind: "idle" });
   }
-  return { status: b, warning: U, busy: J, deploy: Q, reset: tt };
+  return { status: b, warning: j, busy: Q, deploy: T, reset: it };
 }
 export {
-  Pt as useDropDeploy
+  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/buildStash.js

@@ -1,17 +1,20 @@
-const f = "netlify-drop";
+const l = "netlify-drop";
 const s = "build-stash", c = "latest", i = "dropBuildStash";
-const S = (e) => Promise.race([
+const f = (e) => Promise.race([
   e,
   new Promise((r, t) => {
     setTimeout(() => t(new Error("IndexedDB operation timed out")), 3e3);
   })
-]), d = () => new Promise((e, r) => {
-  const t = indexedDB.open(f, 1);
+]), S = () => new Promise((e, r) => {
+  const t = indexedDB.deleteDatabase(l);
+  t.onsuccess = () => e(), t.onblocked = () => e(), t.onerror = () => r(t.error);
+}), p = () => new Promise((e, r) => {
+  const t = indexedDB.open(l, 1);
   t.onupgradeneeded = () => {
     t.result.createObjectStore(s);
   }, t.onsuccess = () => e(t.result), t.onerror = () => r(t.error);
-}), u = (e, r) => S(
-  d().then(
+}), u = (e, r) => f(
+  p().then(
     (t) => new Promise((o, a) => {
       const n = r(t.transaction(s, e).objectStore(s));
       n.onsuccess = () => {
@@ -21,33 +24,42 @@ const S = (e) => Promise.race([
       };
     })
   )
-), p = async (e) => {
+), y = async (e) => {
   const { quota: r, usage: t } = await navigator.storage.estimate();
   return r !== void 0 && t !== void 0 && r - t > e * 2;
 }, T = () => {
-  localStorage.setItem(i, JSON.stringify({ expiresAt: Date.now() + 864e5 }));
-}, l = () => {
+  localStorage.setItem(
+    i,
+    JSON.stringify({ value: "true", expiry: Date.now() + 864e5 })
+  );
+}, d = () => {
   localStorage.removeItem(i);
 };
-async function A(e, r = null) {
+async function O(e, r = null) {
   var t;
   try {
-    if (typeof indexedDB > "u" || !((t = navigator.storage) != null && t.estimate) || e.size > 209715200 || !await p(e.size))
+    if (typeof indexedDB > "u" || !((t = navigator.storage) != null && t.estimate) || e.size > 209715200 || !await y(e.size))
       return !1;
-    const o = { zipFile: e, buildSettings: r, createdAt: Date.now() };
+    const o = {
+      // Round-trip through JSON so an injected detector's richer object can't
+      // fail the structured clone the put() below performs.
+      buildSettings: r && JSON.parse(JSON.stringify(r)),
+      zipFile: e,
+      createdAt: Date.now()
+    };
     return await u("readwrite", (a) => a.put(o, c)), T(), !0;
   } catch {
     return !1;
   }
 }
-async function D() {
+async function w() {
   try {
     if (typeof indexedDB > "u") return null;
     const e = await u(
       "readonly",
       (t) => t.get(c)
     ), r = e && _(e.zipFile);
-    return !e || !r ? null : Date.now() - e.createdAt > 864e5 ? (await y(), null) : { ...e, zipFile: r };
+    return !e || !r ? null : Date.now() - e.createdAt > 864e5 ? (await D(), null) : { ...e, zipFile: r };
   } catch {
     return null;
   }
@@ -55,30 +67,30 @@ async function D() {
 function _(e) {
   return e instanceof File && e.name ? e : e instanceof Blob || e && typeof e.arrayBuffer == "function" ? new File([e], "source.zip", { type: "application/zip" }) : null;
 }
-async function y() {
+async function D() {
   try {
-    l();
+    d();
   } catch {
   }
   try {
     if (typeof indexedDB > "u") return;
-    await u("readwrite", (e) => e.delete(c));
+    await u("readwrite", (e) => e.delete(c)), await f(S());
   } catch {
   }
 }
-function O() {
+function E() {
   try {
     const e = localStorage.getItem(i);
     if (!e) return !1;
-    const { expiresAt: r } = JSON.parse(e);
-    return typeof r != "number" || Date.now() > r ? (l(), !1) : !0;
+    const { value: r, expiry: t } = JSON.parse(e);
+    return r !== "true" || typeof t != "number" || Date.now() > t ? (d(), !1) : !0;
   } catch {
     return !1;
   }
 }
 export {
-  y as clearDropStash,
-  O as hasDropStashMarker,
-  D as loadDropStash,
-  A as saveDropStash
+  D as clearDropStash,
+  E as hasDropStashMarker,
+  w as loadDropStash,
+  O as saveDropStash
 };

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.6",
+  "version": "1.31.0-alpha.8",
   "type": "module",
   "main": "dist/components/preact/index.js",
   "types": "dist/components/preact/index.d.ts",