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

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

@@ -1,27 +1,13 @@
 import { DropClient } from './client';
 import { Digest, DropResponse } from './types';
 export interface AuthenticatedDropClientConfig {
-    /**
-     * Base for JSON API calls, routed through the consumer's access-control
-     * rewrite so the session cookie authenticates them. On netlify.com that
-     * rewrite is `/access-control/*` → the app's access-control function, which
-     * makes `/access-control/bb-api/api/v1` the API root (the default here).
-     */
+    /** Root for session-cookie JSON calls, via the consumer's access-control rewrite. */
     proxyBase?: string;
-    /**
-     * Direct API base for the file uploads. The proxy above runs in a Lambda with
-     * a ~6MB request body limit, so file PUTs go straight to `api.netlify.com`
-     * (whose `/api/*` CORS policy allows any origin).
-     */
+    /** Direct base for file PUTs — the proxy's ~6MB Lambda body limit can't carry uploads. */
     apiBase?: string;
     /**
-     * Mint a bearer token for those direct uploads. On netlify.com this is
-     * `GET /access-control/generate-access-control-token`, whose
-     * `accessControlToken` the API decrypts back into the user's access token.
-     * Resolving `null` means "no session" and surfaces as `NotAuthenticatedError`.
-     *
-     * Called repeatedly, not once: the token issued to a non-app origin lives
-     * only 30 seconds, which a multi-file upload routinely outlasts.
+     * Mint the upload bearer; `null` means "no session". Called repeatedly —
+     * non-app origins get 30-second tokens, which an upload queue outlasts.
      */
     getUploadToken: () => Promise<string | null>;
     /** Create the site in this account. Omit to use the user's default account. */
@@ -32,25 +18,10 @@ export interface AuthenticatedDropClientConfig {
     timeoutMs?: number;
 }
 /**
- * Authenticated drop client for logged-in visitors. Unlike `AnonymousDropClient`
- * — which creates an account-less site the visitor must later claim — this
- * deploys straight into the visitor's account via the sites/deploys API,
- * mirroring what app.netlify.com does for a logged-in drag-and-drop deploy.
- * There is no claim step, so the caller should hand off to the site's dashboard
- * page rather than the claim page.
- *
- * Requests split across two hosts by necessity. JSON calls (create the site,
- * create the deploy, poll it) go through the consumer's access-control proxy on
- * the session cookie — no token involved, and nothing that can expire mid-deploy.
- * File uploads can't: the proxy caps bodies at ~6MB, so they go direct to
- * `api.netlify.com` with a bearer, re-minted as it ages (see `TOKEN_REUSE_MS`).
- *
- * Error-mapping invariant: only pre-mutation failures — a null upload token at
- * the gate, or a 401/403 creating the site — throw `NotAuthenticatedError`,
- * which is the signal the drop flow may safely retry anonymously. Once the site
- * exists, any auth failure throws a plain error instead: falling back at that
- * point would strand an empty site in the account *and* deploy a duplicate
- * anonymously.
+ * Deploys a static drop straight into a logged-in visitor's account — no claim
+ * step. JSON rides the cookie proxy; file PUTs go direct on a re-minted bearer.
+ * Invariant: NotAuthenticatedError only pre-mutation — after the site exists, a
+ * fallback would strand an empty site and deploy a duplicate.
  */
 export declare class AuthenticatedDropClient implements DropClient {
     private proxyBase;
@@ -62,39 +33,19 @@ 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.
+     * A token younger than its 30s expiry. Mint failures here are plain Errors,
+     * never NotAuthenticatedError — the site exists by now (class doc).
      */
     private freshToken;
-    /**
-     * 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.
-     */
+    /** Site + deploy via the proxy, mapped into `DropResponse` so `deployFiles` runs unchanged. */
     createDeploy(files: Digest, _token: string): Promise<DropResponse>;
-    /**
-     * 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.
-     */
+    /** Direct on a fresh bearer (the threaded one has expired). PUT so paths with "&" work. */
     uploadFile(deployId: string, path: string, content: ArrayBuffer, _token: string): Promise<void>;
-    /**
-     * 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.
-     */
+    /** Polls on the session cookie, so a slow deploy can't outlive its own credentials. */
     waitUntilReady(deploy: DropResponse, _token: string): Promise<void>;
 }

package/dist/drop-core/authedDropClient.js

@@ -1,18 +1,18 @@
-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 {
+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 = p,
-    apiBase: t = h,
+    proxyBase: e = u,
+    apiBase: t = y,
     getUploadToken: o,
     accountSlug: s,
-    pollIntervalMs: n = u,
-    timeoutMs: r = y
+    pollIntervalMs: n = T,
+    timeoutMs: r = m
   }) {
     a(this, "proxyBase");
     a(this, "apiBase");
@@ -24,47 +24,35 @@ class M {
     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.
+   * 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 m();
+    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.
-   *
-   * 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.
+   * A token younger than its 30s expiry. Mint failures here are plain Errors,
+   * never NotAuthenticatedError — the site exists by now (class doc).
    */
   async freshToken() {
     const e = Date.now();
-    if (this.cachedToken && e - this.cachedToken.mintedAt < k)
+    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.
-   */
+  /** Site + deploy via the proxy, mapped into `DropResponse` so `deployFiles` runs unchanged. */
   async createDeploy(e, t) {
-    const o = await T(this.proxyBase, this.accountSlug), s = await fetch(`${this.proxyBase}/sites/${o.id}/deploys`, {
+    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 d("deploy create", s.status);
+    if (!s.ok) throw l("deploy create", s.status);
     const n = await s.json();
     return {
       id: o.id,
@@ -73,37 +61,27 @@ class M {
       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.
-   */
+  /** Direct on a fresh bearer (the threaded one has expired). PUT so paths with "&" 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);
+    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.
-   */
+  /** Polls on the session cookie, so a slow deploy can't outlive its own credentials. */
   async waitUntilReady(e, t) {
-    const o = await w({
+    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 Error(
-        o.errorMessage ? `deploy failed: ${o.errorMessage}` : "deploy failed"
-      ) : new Error("Deploy did not become ready in time");
+      throw o.outcome === "failed" ? new f(o.errorMessage) : new _();
   }
 }
 export {
-  M as AuthenticatedDropClient
+  B as AuthenticatedDropClient
 };

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

@@ -2,7 +2,6 @@ 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 */
     id: string;
     /** the deploy the build produces — present as soon as the build is enqueued */
     deploy_id?: string;
@@ -13,28 +12,14 @@ export interface BuildClient {
     waitUntilBuildReady(build: BuildResponse): Promise<void>;
 }
 export interface AuthenticatedBuildClientConfig {
-    /**
-     * Base for JSON API calls, routed through the consumer's access-control
-     * rewrite so the session cookie authenticates them. On netlify.com that
-     * rewrite is `/access-control/*` → the app's access-control function, which
-     * makes `/access-control/bb-api/api/v1` the API root (the default here).
-     */
+    /** Root for session-cookie JSON calls, via the consumer's access-control rewrite. */
     proxyBase?: string;
-    /**
-     * Direct API base for the zip upload. The proxy above runs in a Lambda with a
-     * ~6MB request body limit, so the multipart POST has to go straight to
-     * `api.netlify.com` (whose `/api/*` CORS policy allows any origin).
-     */
+    /** Direct base for the zip upload — the proxy's ~6MB Lambda body limit can't carry it. */
     apiBase?: string;
     /**
-     * Mint a bearer token for that direct upload. On netlify.com this is
-     * `GET /access-control/generate-access-control-token`, whose
-     * `accessControlToken` the API decrypts back into the user's access token.
-     * Resolving `null` means "no session" and surfaces as `NotAuthenticatedError`.
-     *
-     * Note the token issued to a non-app origin lives only 30 seconds. It is
-     * minted immediately before the upload, but a zip that takes longer than that
-     * to transfer will still be rejected mid-flight — see `createBuildFromZip`.
+     * Mint the upload bearer; `null` means "no session". Non-app origins get
+     * 30-second tokens — a zip slower than that fails mid-flight (see
+     * `createBuildFromZip`).
      */
     getUploadToken: () => Promise<string | null>;
     /** Create the site in this account. Omit to use the user's default account. */
@@ -47,16 +32,9 @@ export interface AuthenticatedBuildClientConfig {
     timeoutMs?: number;
 }
 /**
- * Authenticated drop client for projects that need a build. Unlike
- * `AnonymousDropClient` — which creates an account-less static site and can only
- * upload pre-built files — this creates a real site in the user's account and
- * hands buildbot a source archive to build, mirroring what app.netlify.com does
- * for a drag-and-drop build.
- *
- * Requests split across two hosts by necessity: JSON calls go through the
- * consumer's access-control proxy (cookie session, no token handling in the
- * browser), while the zip upload goes direct to `api.netlify.com` with a
- * short-lived bearer token because the proxy can't carry a body that large.
+ * Builds a drop in a logged-in visitor's account: create the site, hand
+ * buildbot the source zip. JSON rides the cookie proxy; the zip goes direct
+ * with a bearer (the proxy can't carry it).
  */
 export declare class AuthenticatedBuildClient implements BuildClient {
     private proxyBase;
@@ -67,35 +45,23 @@ export declare class AuthenticatedBuildClient implements BuildClient {
     private pollIntervalMs;
     private timeoutMs;
     constructor({ proxyBase, apiBase, getUploadToken, accountSlug, title, pollIntervalMs, timeoutMs, }: AuthenticatedBuildClientConfig);
-    /**
-     * 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.
-     */
+    /** A logged-out visitor fails here, before anything is created (see `createSiteInAccount`). */
     createSite(): Promise<BuildSite>;
     /**
-     * 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.
+     * One multipart request on a fresh 30s bearer — a slower zip fails mid-flight
+     * (the app origin gets 300s; raising ours is a platform-side change).
+     * Content-Type stays unset so the browser adds the multipart boundary.
      *
-     * 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.
+     * Never NotAuthenticatedError, including for a 401: the site exists by the
+     * time this runs, so signalling "no session" would strand it and re-stash
+     * the drop for the next visit to strand another. `createSite` is the auth
+     * gate for this path.
      */
     createBuildFromZip(siteId: string, zip: File): Promise<BuildResponse>;
     /**
-     * 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.
+     * Optional (a build takes minutes; the useful hand-off is the project page).
+     * Polls on the cookie, so it can't outlive its credentials; no deploy id yet
+     * means nothing pollable, so it resolves immediately.
      */
     waitUntilBuildReady(build: BuildResponse): Promise<void>;
 }

package/dist/drop-core/buildClient.js

@@ -1,17 +1,18 @@
 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";
+var u = (i, t, e) => t in i ? d(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var o = (i, t, e) => u(i, 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 { BuildCreateError as l, BuildFailedError as M, BuildTimeoutError as T } from "./errors.js";
 class _ {
   constructor({
-    proxyBase: t = c,
-    apiBase: e = h,
+    proxyBase: t = m,
+    apiBase: e = B,
     getUploadToken: a,
-    accountSlug: s,
-    title: i = "Build from drop deployment",
-    pollIntervalMs: n = B,
-    timeoutMs: u = m
+    accountSlug: r,
+    title: s = "Build from drop deployment",
+    pollIntervalMs: n = y,
+    timeoutMs: p = w
   }) {
     o(this, "proxyBase");
     o(this, "apiBase");
@@ -20,63 +21,50 @@ class _ {
     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;
+    this.proxyBase = t, this.apiBase = e, this.getUploadToken = a, this.accountSlug = r, this.title = s, 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.
-   */
+  /** A logged-out visitor fails here, before anything is created (see `createSiteInAccount`). */
   async createSite() {
-    return y(this.proxyBase, this.accountSlug);
+    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.
+   * One multipart request on a fresh 30s bearer — a slower zip fails mid-flight
+   * (the app origin gets 300s; raising ours is a platform-side change).
+   * Content-Type stays unset so the browser adds the multipart boundary.
    *
-   * 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.
+   * Never NotAuthenticatedError, including for a 401: the site exists by the
+   * time this runs, so signalling "no session" would strand it and re-stash
+   * the drop for the next visit to strand another. `createSite` is the auth
+   * gate for this path.
    */
   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`, {
+    const r = new FormData();
+    r.append("zip", e), r.append("title", this.title);
+    const s = await fetch(`${this.apiBase}/sites/${t}/builds`, {
       method: "POST",
       headers: { Authorization: `Bearer ${a}` },
-      body: s
+      body: r
     });
-    if (i.status === 401 || i.status === 403) throw new l();
-    if (!i.ok) throw new A(i.status);
-    return i.json();
+    if (!s.ok) throw new l(s.status);
+    return s.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.
+   * Optional (a build takes minutes; the useful hand-off is the project page).
+   * Polls on the cookie, so it can't outlive its credentials; no deploy id yet
+   * means nothing pollable, so it resolves immediately.
    */
   async waitUntilBuildReady(t) {
     if (!t.deploy_id) return;
-    const e = await w({
+    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 E(e.errorMessage) : new M();
+      throw e.outcome === "failed" ? new M(e.errorMessage) : new T();
   }
 }
 export {

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

@@ -1,20 +1,10 @@
 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.
+ * Carries a build drop across the signup round-trip: stash the zip in
+ * IndexedDB before the hand-off, deploy it when the visitor returns
+ * authenticated. Storage is per-origin by design — the hand-off must bring
+ * them back here. Every operation swallows failures: no storage means the
+ * plain signup redirect the zone always supported.
  */
 export interface DropBuildStash {
     /** The `source.zip` exactly as it would have been uploaded. */
@@ -23,11 +13,7 @@ export interface DropBuildStash {
     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.
- */
+/** Stash the archive for auto-deploy after signup. The result phrases the hand-off, never blocks 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>;

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

@@ -11,11 +11,13 @@ export interface DropClient {
 }
 /**
  * Unauthenticated drop client. Authorized server-side by the Referer header,
- * so it only works from an allowlisted origin (see backend checklist).
+ * so it only works from an allowlisted origin.
  */
 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

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

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

@@ -0,0 +1,9 @@
+/** Tunables shared across drop-core. Module-specific constants stay with their module. */
+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;
+export declare const TOKEN_REUSE_MS: number;
+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
+};