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

package/dist/drop-core/authedDropClient.js

@@ -0,0 +1,109 @@
+var l = Object.defineProperty;
+var c = (i, e, t) => e in i ? l(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var a = (i, e, t) => c(i, typeof e != "symbol" ? e + "" : e, t);
+import { DEFAULT_PROXY_BASE as p, DEFAULT_API_BASE as h, DEFAULT_POLL_INTERVAL_MS as u, DEFAULT_TIMEOUT_MS as y, createSiteInAccount as T, pollDeployUntilSettled as w } from "./authedApi.js";
+import { apiError as d } from "./client.js";
+import { NotAuthenticatedError as m } from "./errors.js";
+const k = 20 * 1e3;
+class M {
+  constructor({
+    proxyBase: e = p,
+    apiBase: t = h,
+    getUploadToken: o,
+    accountSlug: s,
+    pollIntervalMs: n = u,
+    timeoutMs: r = y
+  }) {
+    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. 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.
+   */
+  async getToken() {
+    const e = await this.getUploadToken();
+    if (!e) throw new m();
+    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.
+   *
+   * 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.
+   */
+  async freshToken() {
+    const e = Date.now();
+    if (this.cachedToken && e - this.cachedToken.mintedAt < k)
+      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 T(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 d("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 d(`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 w({
+      proxyBase: this.proxyBase,
+      deployId: e.deploy_id,
+      pollIntervalMs: this.pollIntervalMs,
+      timeoutMs: this.timeoutMs
+    });
+    if (o.outcome !== "ready")
+      throw o.outcome === "failed" ? new Error(
+        o.errorMessage ? `deploy failed: ${o.errorMessage}` : "deploy failed"
+      ) : new Error("Deploy did not become ready in time");
+  }
+}
+export {
+  M 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,84 @@
+var d = Object.defineProperty;
+var p = (r, t, e) => t in r ? d(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var o = (r, t, e) => p(r, typeof t != "symbol" ? t + "" : t, e);
+import { DEFAULT_PROXY_BASE as c, DEFAULT_API_BASE as h, DEFAULT_POLL_INTERVAL_MS as B, DEFAULT_TIMEOUT_MS as m, createSiteInAccount as y, pollDeployUntilSettled as w } from "./authedApi.js";
+import { NotAuthenticatedError as l, BuildCreateError as A, BuildFailedError as E, BuildTimeoutError as M } from "./errors.js";
+class _ {
+  constructor({
+    proxyBase: t = c,
+    apiBase: e = h,
+    getUploadToken: a,
+    accountSlug: s,
+    title: i = "Build from drop deployment",
+    pollIntervalMs: n = B,
+    timeoutMs: u = m
+  }) {
+    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 = u;
+  }
+  /**
+   * 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 y(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 A(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 w({
+      proxyBase: this.proxyBase,
+      deployId: t.deploy_id,
+      pollIntervalMs: this.pollIntervalMs,
+      timeoutMs: this.timeoutMs
+    });
+    if (e.outcome !== "ready")
+      throw e.outcome === "failed" ? new E(e.errorMessage) : new M();
+  }
+}
+export {
+  _ 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}/deploy.d.ts

@@ -2,6 +2,7 @@ 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;
 }
@@ -35,3 +36,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,53 @@
+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;
+  const d = async () => {
+    for (; u < l.length; ) {
+      const h = l[u++];
+      await i.uploadFile(n, h.path, h.content, t), e == null || e(++c);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(r, l.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 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 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`
+  };
+}
+export {
+  F as deployBuild,
+  B as deployFiles,
+  o 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.js

@@ -40,7 +40,7 @@ function h(e) {
   if (e instanceof o)
     return "To deploy, drop a folder or a .zip file — or a single HTML page.";
   if (e instanceof s)
-    return "Please log in to Netlify to deploy a project that needs a build, then try again.";
+    return "Please log in to Netlify to deploy this project, then try again.";
   if (e instanceof u)
     return "We couldn't create a project for this build. Please try again.";
   if (e instanceof l)

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

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

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

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

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

@@ -4,8 +4,11 @@ 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';

package/dist/drop-core/index.js

@@ -0,0 +1,51 @@
+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";
+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
+};

package/dist/{components/preact/DropZone/drop-core → drop-core}/readFiles.js

@@ -1,4 +1,4 @@
-import { g as P } from "../../../../chunks/_commonjsHelpers.C6fGbg64.js";
+import { g as P } from "../chunks/_commonjsHelpers.C6fGbg64.js";
 import { UnsupportedDropError as U } from "./errors.js";
 var L = { exports: {} }, G = L.exports, D;
 function J() {
@@ -579,7 +579,7 @@ async function Q(y) {
   return M(w);
 }
 async function I(y) {
-  const { unzip: m } = await import("../../../../chunks/browser.Ca2rTNTu.js"), w = new Uint8Array(await y.arrayBuffer()), _ = await new Promise(
+  const { unzip: m } = await import("../chunks/browser.Ca2rTNTu.js"), w = new Uint8Array(await y.arrayBuffer()), _ = await new Promise(
     (v, s) => m(w, (g, u) => g ? s(g) : v(u))
   ), h = [];
   for (const [v, s] of Object.entries(_)) {

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

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

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

@@ -41,3 +41,13 @@ export interface DeployProgress {
     uploaded?: number;
     total?: number;
 }
+/** 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;
+}

package/dist/{components/preact/DropZone/drop-core → drop-core}/zip.js

@@ -29,7 +29,7 @@ async function $(e, { name: i = "source.zip", synthesizeNetlifyToml: p = !0 } =
 ${n}` : n;
     l["netlify.toml"] = m.encode(c);
   }
-  const { zip: f } = await import("../../../../chunks/browser.Ca2rTNTu.js"), o = await new Promise(
+  const { zip: f } = await import("../chunks/browser.Ca2rTNTu.js"), o = await new Promise(
     (t, n) => f(l, { level: 6 }, (c, s) => c ? n(c) : t(s))
   ), u = o.buffer.slice(
     o.byteOffset,

package/dist/drop-core/zip.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.3",
+  "version": "1.31.0-alpha.4",
   "type": "module",
   "main": "dist/components/preact/index.js",
   "types": "dist/components/preact/index.d.ts",
@@ -26,6 +26,7 @@
   ],
   "exports": {
     "./preact": "./dist/components/preact/index.js",
+    "./drop-core": "./dist/drop-core/index.js",
     "./assets/*.css": "./dist/assets/*.css",
     "./assets/icons/*.svg": "./packages/assets/icons/*.svg",
     "./logos/*.svg": "./packages/assets/logos/*.svg",
@@ -61,7 +62,9 @@
     "eslint": "^10.0.0",
     "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-astro": "^1.3.1",
+    "fake-indexeddb": "^6.2.5",
     "glob": "^11.0.1",
+    "happy-dom": "^20.11.6",
     "jsdom": "^30.0.0",
     "preact": "^10.26.4",
     "prettier": "^3.5.3",

package/packages/components/index.ts

@@ -11,6 +11,15 @@ export {
   AnonymousDropClient,
   AuthenticatedBuildClient,
   AuthenticatedDropClient,
+  BuildCreateError,
+  BuildFailedError,
+  BuildTimeoutError,
+  DROPZONE_EVENTS,
+  getFileTypes,
+  humanizeDropError,
+  NotAuthenticatedError,
+  SiteCreateError,
+  UnsupportedDropError,
   deployBuild,
   deployFiles,
   detectBuild,
@@ -23,6 +32,16 @@ export type {
   AuthenticatedBuildClientConfig,
   AuthenticatedDropClientConfig,
   BuildClient,
+  BuildDeployOptions,
+  BuildReason,
+  BuildResponse,
+  DeployError,
+  DeployStatus,
+  DropZoneEventName,
+  DropZoneEventProperties,
+  TrackFn,
+  ZipOptions,
+  ZipResult,
   BuildDeployResult,
   BuildDetection,
   BuildSite,