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

package/dist/{components/preact/DropZone/drop-core → drop-core}/authedDropClient.d.ts

@@ -62,21 +62,14 @@ export declare class AuthenticatedDropClient implements DropClient {
     private cachedToken?;
     constructor({ proxyBase, apiBase, getUploadToken, accountSlug, pollIntervalMs, timeoutMs, }: AuthenticatedDropClientConfig);
     /**
-     * The auth gate. Minting here — before anything is created — is what lets a
-     * logged-out visitor fail cleanly and fall back to the anonymous flow. The
-     * returned token is threaded through `deployFiles`, but only the uploads
-     * actually need one, and they re-mint rather than trusting this to still be
-     * valid by the time they run.
+     * The auth gate: minting here, before anything is created, is what lets a
+     * logged-out visitor fail cleanly and fall back to the anonymous flow.
      */
     getToken(): Promise<string>;
     /**
      * A token young enough to authorize an upload, minting a new one once the
-     * cached one nears its 30s expiry.
-     *
-     * Deliberately NOT `NotAuthenticatedError` when minting fails: by the time
-     * uploads run the site already exists, and that error would send the drop
-     * back through the anonymous path — leaving an empty project behind and
-     * deploying a duplicate. See the class doc.
+     * cached one nears its 30s expiry. A mint failure here is a plain `Error`,
+     * never `NotAuthenticatedError` — the site exists by now (class doc).
      */
     private freshToken;
     /**

package/dist/drop-core/authedDropClient.js

@@ -0,0 +1,100 @@
+var c = Object.defineProperty;
+var d = (i, e, t) => e in i ? c(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var a = (i, e, t) => d(i, typeof e != "symbol" ? e + "" : e, t);
+import { createSiteInAccount as p, pollDeployUntilSettled as h } from "./authedApi.js";
+import { DEFAULT_PROXY_BASE as u, DEFAULT_API_BASE as y, DEFAULT_POLL_INTERVAL_MS as T, DEFAULT_TIMEOUT_MS as m, TOKEN_REUSE_MS as w } from "./constants.js";
+import { apiError as l } from "./client.js";
+import { NotAuthenticatedError as k, DeployFailedError as f, DeployTimeoutError as _ } from "./errors.js";
+class B {
+  constructor({
+    proxyBase: e = u,
+    apiBase: t = y,
+    getUploadToken: o,
+    accountSlug: s,
+    pollIntervalMs: n = T,
+    timeoutMs: r = m
+  }) {
+    a(this, "proxyBase");
+    a(this, "apiBase");
+    a(this, "getUploadToken");
+    a(this, "accountSlug");
+    a(this, "pollIntervalMs");
+    a(this, "timeoutMs");
+    a(this, "cachedToken");
+    this.proxyBase = e, this.apiBase = t, this.getUploadToken = o, this.accountSlug = s, this.pollIntervalMs = n, this.timeoutMs = r;
+  }
+  /**
+   * The auth gate: minting here, before anything is created, is what lets a
+   * logged-out visitor fail cleanly and fall back to the anonymous flow.
+   */
+  async getToken() {
+    const e = await this.getUploadToken();
+    if (!e) throw new k();
+    return this.cachedToken = { value: e, mintedAt: Date.now() }, e;
+  }
+  /**
+   * A token young enough to authorize an upload, minting a new one once the
+   * cached one nears its 30s expiry. A mint failure here is a plain `Error`,
+   * never `NotAuthenticatedError` — the site exists by now (class doc).
+   */
+  async freshToken() {
+    const e = Date.now();
+    if (this.cachedToken && e - this.cachedToken.mintedAt < w)
+      return this.cachedToken.value;
+    const t = await this.getUploadToken();
+    if (!t) throw new Error("could not renew the upload token");
+    return this.cachedToken = { value: t, mintedAt: e }, t;
+  }
+  /**
+   * Two proxied calls: create the site in the visitor's account, then the
+   * deploy on it. Mapped into the anonymous `DropResponse` shape so
+   * `deployFiles` runs unchanged over either client.
+   */
+  async createDeploy(e, t) {
+    const o = await p(this.proxyBase, this.accountSlug), s = await fetch(`${this.proxyBase}/sites/${o.id}/deploys`, {
+      method: "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ files: e, deploy_source: "drop" })
+    });
+    if (!s.ok) throw l("deploy create", s.status);
+    const n = await s.json();
+    return {
+      id: o.id,
+      deploy_id: n.id,
+      subdomain: o.name,
+      required: n.required ?? []
+    };
+  }
+  /**
+   * Direct to `api.netlify.com` on a freshly-aged bearer — the threaded `token`
+   * is ignored because an upload queue easily outlives the 30 seconds it was
+   * minted with. PUT (not POST) so paths with "&" etc. work.
+   */
+  async uploadFile(e, t, o, s) {
+    const n = await this.freshToken(), r = await fetch(`${this.apiBase}/deploys/${e}/files${t}`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/octet-stream", Authorization: `Bearer ${n}` },
+      body: o
+    });
+    if (!r.ok) throw l(`upload ${t}`, r.status);
+  }
+  /**
+   * Poll the deploy through the proxy until it settles: resolve on `ready`,
+   * throw on `error`/`rejected`, throw on timeout. On the session cookie rather
+   * than a bearer, so a deploy taking minutes can't outlive its own credentials.
+   */
+  async waitUntilReady(e, t) {
+    const o = await h({
+      proxyBase: this.proxyBase,
+      deployId: e.deploy_id,
+      pollIntervalMs: this.pollIntervalMs,
+      timeoutMs: this.timeoutMs
+    });
+    if (o.outcome !== "ready")
+      throw o.outcome === "failed" ? new f(o.errorMessage) : new _();
+  }
+}
+export {
+  B as AuthenticatedDropClient
+};

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

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

package/dist/{components/preact/DropZone/drop-core → drop-core}/buildClient.d.ts

@@ -1,13 +1,5 @@
-/** The subset of a Netlify Site the drop flow needs to redirect and report. */
-export interface BuildSite {
-    /** site id (UUID) */
-    id: string;
-    /** the *.netlify.app subdomain, also the app's URL segment */
-    name: string;
-    /** https://<name>.netlify.app */
-    ssl_url?: string;
-    url?: string;
-}
+import { BuildSite } from './types';
+export type { BuildSite } from './types';
 /** The subset of a Netlify Build returned by `POST /sites/{id}/builds`. */
 export interface BuildResponse {
     /** build id */
@@ -76,9 +68,9 @@ export declare class AuthenticatedBuildClient implements BuildClient {
     private timeoutMs;
     constructor({ proxyBase, apiBase, getUploadToken, accountSlug, title, pollIntervalMs, timeoutMs, }: AuthenticatedBuildClientConfig);
     /**
-     * Create the site the build deploys into. Goes through the proxy with
-     * `credentials: 'include'` so the app session authorizes it; without an
-     * account slug the API picks the user's default account.
+     * Create the site the build deploys into. A logged-out visitor fails here,
+     * before anything is created — see `createSiteInAccount` for the error
+     * mapping that makes the signup fallback safe.
      */
     createSite(): Promise<BuildSite>;
     /**

package/dist/drop-core/buildClient.js

@@ -0,0 +1,85 @@
+var u = Object.defineProperty;
+var d = (r, t, e) => t in r ? u(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var o = (r, t, e) => d(r, typeof t != "symbol" ? t + "" : t, e);
+import { createSiteInAccount as c, pollDeployUntilSettled as h } from "./authedApi.js";
+import { DEFAULT_PROXY_BASE as m, DEFAULT_API_BASE as B, DEFAULT_POLL_INTERVAL_MS as y, DEFAULT_TIMEOUT_MS as w } from "./constants.js";
+import { NotAuthenticatedError as l, BuildCreateError as f, BuildFailedError as A, BuildTimeoutError as E } from "./errors.js";
+class U {
+  constructor({
+    proxyBase: t = m,
+    apiBase: e = B,
+    getUploadToken: a,
+    accountSlug: s,
+    title: i = "Build from drop deployment",
+    pollIntervalMs: n = y,
+    timeoutMs: p = w
+  }) {
+    o(this, "proxyBase");
+    o(this, "apiBase");
+    o(this, "getUploadToken");
+    o(this, "accountSlug");
+    o(this, "title");
+    o(this, "pollIntervalMs");
+    o(this, "timeoutMs");
+    this.proxyBase = t, this.apiBase = e, this.getUploadToken = a, this.accountSlug = s, this.title = i, this.pollIntervalMs = n, this.timeoutMs = p;
+  }
+  /**
+   * Create the site the build deploys into. A logged-out visitor fails here,
+   * before anything is created — see `createSiteInAccount` for the error
+   * mapping that makes the signup fallback safe.
+   */
+  async createSite() {
+    return c(this.proxyBase, this.accountSlug);
+  }
+  /**
+   * Upload the source archive and enqueue a build. Direct to `api.netlify.com`
+   * (see the note on `apiBase`), authorized by a freshly minted bearer token.
+   * `Content-Type` is left unset on purpose so the browser adds the multipart
+   * boundary itself.
+   *
+   * Known ceiling: this is one request on a 30s token, and re-minting can't
+   * help once it is in flight. A zip that takes longer than that to upload will
+   * fail — the app origin gets 300s for exactly this reason, and lifting the
+   * limit for other origins is a platform-side change.
+   */
+  async createBuildFromZip(t, e) {
+    const a = await this.getUploadToken();
+    if (!a) throw new l();
+    const s = new FormData();
+    s.append("zip", e), s.append("title", this.title);
+    const i = await fetch(`${this.apiBase}/sites/${t}/builds`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${a}` },
+      body: s
+    });
+    if (i.status === 401 || i.status === 403) throw new l();
+    if (!i.ok) throw new f(i.status);
+    return i.json();
+  }
+  /**
+   * Poll the build's deploy until it settles, mirroring
+   * `AnonymousDropClient.waitUntilReady` — resolve on `ready`, throw on
+   * `error`/`rejected`, throw on timeout. A build that hasn't been given a
+   * deploy id yet has nothing pollable, so it resolves immediately and the
+   * caller falls back to the site page.
+   *
+   * Optional in the drop flow, and off by default: a build takes minutes, so
+   * the useful hand-off is usually the project page rather than a spinner.
+   * Polling rides the session cookie, so it cannot outlive its credentials the
+   * way a 30s bearer would.
+   */
+  async waitUntilBuildReady(t) {
+    if (!t.deploy_id) return;
+    const e = await h({
+      proxyBase: this.proxyBase,
+      deployId: t.deploy_id,
+      pollIntervalMs: this.pollIntervalMs,
+      timeoutMs: this.timeoutMs
+    });
+    if (e.outcome !== "ready")
+      throw e.outcome === "failed" ? new A(e.errorMessage) : new E();
+  }
+}
+export {
+  U as AuthenticatedBuildClient
+};

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

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

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

@@ -0,0 +1,37 @@
+import { InferredBuildSettings } from './detectBuild';
+/**
+ * Carry a build-required drop across the signup round-trip.
+ *
+ * A logged-out visitor's drop can't be built (builds have no anonymous
+ * equivalent), so before handing them to signup the zone stashes the source
+ * archive here — IndexedDB, because the zip is far beyond localStorage's
+ * budget. When they return to this origin authenticated, the zone deploys the
+ * stash automatically instead of asking them to drop again.
+ *
+ * Storage is per-origin: a stash written on www.netlify.com can only ever be
+ * resumed on www.netlify.com. That is the design, not a limitation — it is
+ * exactly why the hand-off page must bring the visitor back here.
+ *
+ * Every operation is failure-swallowing: the stash is an enhancement, and a
+ * browser without IndexedDB (or with a full quota) degrades to the plain
+ * signup redirect the zone always supported.
+ */
+export interface DropBuildStash {
+    /** The `source.zip` exactly as it would have been uploaded. */
+    zipFile: File;
+    /** Settings synthesised into the archive's netlify.toml, if any. */
+    buildSettings: InferredBuildSettings | null;
+    createdAt: number;
+}
+/**
+ * Stash a drop's source archive for an automatic deploy after signup. Returns
+ * whether it was actually stored — callers use that only to phrase the
+ * hand-off, never to block it.
+ */
+export declare function saveDropStash(zipFile: File, buildSettings?: InferredBuildSettings | null): Promise<boolean>;
+/** The stashed drop, or null when there is none, it expired, or storage is unavailable. */
+export declare function loadDropStash(): Promise<DropBuildStash | null>;
+/** Remove the stash and its marker. Idempotent; never throws. */
+export declare function clearDropStash(): Promise<void>;
+/** Cheap synchronous check so page loads don't open IndexedDB just to look for a stash. */
+export declare function hasDropStashMarker(): boolean;

package/dist/drop-core/buildStash.js

@@ -0,0 +1,84 @@
+const f = "netlify-drop";
+const s = "build-stash", c = "latest", i = "dropBuildStash";
+const S = (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);
+  t.onupgradeneeded = () => {
+    t.result.createObjectStore(s);
+  }, t.onsuccess = () => e(t.result), t.onerror = () => r(t.error);
+}), u = (e, r) => S(
+  d().then(
+    (t) => new Promise((o, a) => {
+      const n = r(t.transaction(s, e).objectStore(s));
+      n.onsuccess = () => {
+        t.close(), o(n.result);
+      }, n.onerror = () => {
+        t.close(), a(n.error);
+      };
+    })
+  )
+), p = 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.removeItem(i);
+};
+async function A(e, r = null) {
+  var t;
+  try {
+    if (typeof indexedDB > "u" || !((t = navigator.storage) != null && t.estimate) || e.size > 209715200 || !await p(e.size))
+      return !1;
+    const o = { zipFile: e, buildSettings: r, createdAt: Date.now() };
+    return await u("readwrite", (a) => a.put(o, c)), T(), !0;
+  } catch {
+    return !1;
+  }
+}
+async function D() {
+  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 };
+  } catch {
+    return null;
+  }
+}
+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() {
+  try {
+    l();
+  } catch {
+  }
+  try {
+    if (typeof indexedDB > "u") return;
+    await u("readwrite", (e) => e.delete(c));
+  } catch {
+  }
+}
+function O() {
+  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;
+  } catch {
+    return !1;
+  }
+}
+export {
+  y as clearDropStash,
+  O as hasDropStashMarker,
+  D as loadDropStash,
+  A as saveDropStash
+};

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

@@ -15,7 +15,9 @@ export interface DropClient {
  */
 export declare class AnonymousDropClient implements DropClient {
     private apiBase;
-    constructor(apiBase?: string);
+    private pollIntervalMs;
+    private timeoutMs;
+    constructor(apiBase?: string, pollIntervalMs?: number, timeoutMs?: number);
     getToken(): Promise<string>;
     createDeploy(files: Digest, token: string): Promise<DropResponse>;
     uploadFile(deployId: string, path: string, content: ArrayBuffer, token: string): Promise<void>;

package/dist/drop-core/client.js

@@ -0,0 +1,47 @@
+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 });
+}
+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 i("drop/token", t.status);
+    return (await t.json()).token;
+  }
+  async createDeploy(t, o) {
+    const e = await fetch(`${this.apiBase}/drop`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ files: t, token: o })
+    });
+    if (!e.ok) throw i("drop", e.status);
+    return e.json();
+  }
+  async uploadFile(t, o, e, a) {
+    const s = await fetch(`${this.apiBase}/deploys/${t}/files${o}`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/octet-stream", Authorization: `Bearer ${a}` },
+      body: e
+    });
+    if (!s.ok) throw i(`upload ${o}`, s.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();
+  }
+}
+export {
+  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/{components/preact/DropZone/drop-core → drop-core}/deploy.d.ts

@@ -2,8 +2,11 @@ import { BuildClient, BuildResponse, BuildSite } from './buildClient';
 import { DropClient } from './client';
 import { InferredBuildSettings } from './detectBuild';
 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 {
@@ -35,3 +38,9 @@ export interface BuildDeployOptions extends DeployOptions {
  * doesn't leave an empty site behind in the user's account.
  */
 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.
+ */
+export declare function deployZippedBuild(client: BuildClient, { file: zip, buildSettings }: ZipResult, opts?: BuildDeployOptions): Promise<BuildDeployResult>;

package/dist/drop-core/deploy.js

@@ -0,0 +1,66 @@
+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 (; 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(o, p.length) }, d));
+}
+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 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 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 {
+  B as deployBuild,
+  T as deployFiles,
+  S as deployZippedBuild
+};

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

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

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

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

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

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

package/dist/{components/preact/DropZone/drop-core → 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();
 }
 /**