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

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

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

package/dist/components/preact/DropZone/useDropDeploy.test.d.ts

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

package/dist/components/preact/index.d.ts

@@ -6,6 +6,6 @@ export { default as SearchHeading } from './SearchModal/components/SearchHeading
 export { default as SearchToggle } from './SearchModal/components/SearchToggle/SearchToggle';
 export { default as AskNetlify } from './AskNetlify/AskNetlify';
 export { SearchModal } from './SearchModal';
-export { DropZone, AuthenticatedBuildClient, AuthenticatedDropClient } from './DropZone';
-export type { BuildClient, DeployedBuild, DeployedSite, DropClient } from './DropZone';
+export { DropZone, AuthenticatedBuildClient, AuthenticatedDropClient, DROPZONE_EVENTS, getFileTypes, humanizeDropError, } from './DropZone';
+export type { BuildClient, DeployedBuild, DeployedSite, DeployError, DeployStatus, DropClient, DropZoneEventName, DropZoneEventProperties, TrackFn, } from './DropZone';
 export { type IconName } from './Icon';

package/dist/components/preact/index.js

@@ -1,29 +1,35 @@
 import { default as m } from "./KeyboardKey/KeyboardKey.js";
-import { default as l } from "./Modal/Modal.js";
-import { default as u } from "./Icon/index.js";
+import { default as d } from "./Modal/Modal.js";
+import { default as x } from "./Icon/index.js";
 import { default as s } from "./SearchModal/components/SearchLink/SearchLink.js";
 import { default as c } from "./SearchModal/components/SearchHeading/SearchHeading.js";
-import { default as A } from "./SearchModal/components/SearchToggle/SearchToggle.js";
-import { A as g } from "../../chunks/AskNetlify.bx0blyGV.js";
+import { default as S } from "./SearchModal/components/SearchToggle/SearchToggle.js";
+import { A as y } from "../../chunks/AskNetlify.bx0blyGV.js";
 import "preact";
 import "../../chunks/hooks.module.DRcxknIz.js";
-import { default as k } from "./SearchModal/components/SearchModal/SearchModal.js";
-import { default as D } from "./DropZone/DropZone.js";
-import "./DropZone/drop-core/readFiles.js";
-import "./DropZone/drop-core/detectBuild.js";
-import { AuthenticatedDropClient as M } from "./DropZone/drop-core/authedDropClient.js";
-import { AuthenticatedBuildClient as B } from "./DropZone/drop-core/buildClient.js";
-import "./DropZone/drop-core/zip.js";
+import { default as D } from "./SearchModal/components/SearchModal/SearchModal.js";
+import { default as N } from "./DropZone/DropZone.js";
+import "../../drop-core/readFiles.js";
+import { getFileTypes as k } from "../../drop-core/fileTypes.js";
+import "../../drop-core/detectBuild.js";
+import { humanizeDropError as K } from "../../drop-core/errors.js";
+import { AuthenticatedDropClient as O } from "../../drop-core/authedDropClient.js";
+import { AuthenticatedBuildClient as b } from "../../drop-core/buildClient.js";
+import "../../drop-core/zip.js";
+import { DROPZONE_EVENTS as B } from "../../drop-core/analytics.js";
 export {
-  g as AskNetlify,
-  B as AuthenticatedBuildClient,
-  M as AuthenticatedDropClient,
-  D as DropZone,
-  u as Icon,
+  y as AskNetlify,
+  b as AuthenticatedBuildClient,
+  O as AuthenticatedDropClient,
+  B as DROPZONE_EVENTS,
+  N as DropZone,
+  x as Icon,
   m as KeyboardKey,
-  l as Modal,
+  d as Modal,
   c as SearchHeading,
   s as SearchLink,
-  k as SearchModal,
-  A as SearchToggle
+  D as SearchModal,
+  S as SearchToggle,
+  k as getFileTypes,
+  K as humanizeDropError
 };

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

@@ -0,0 +1,107 @@
+import { BuildReason } from './detectBuild';
+/**
+ * The Drop Zone's analytics contract — the canonical event names and property
+ * shapes, exported so no consumer (this package's own component, a host site's
+ * GTM wiring, or another Netlify surface implementing its own Drop UI over
+ * drop-core) ever hand-writes the strings.
+ */
+/** How the files reached the zone — carried on every drop-initiated event as `method`. */
+export type DropMethod = 'drag' | 'browse';
+/**
+ * Canonical Drop Zone lifecycle events. The values are the wire names:
+ * analytics history in Amplitude/Segment keys off these exact strings, so
+ * renaming a value silently forks every funnel built on it — treat them as
+ * append-only.
+ */
+export declare const DROPZONE_EVENTS: {
+    /** Files arrived via drag — the picker path reports its files on outcome events instead. */
+    readonly FILES_DROPPED: "dropzone_files_dropped";
+    /** The native file picker was opened (keyboard or click). */
+    readonly BROWSE_OPENED: "dropzone_browse_opened";
+    /** The drop needs a build — it will be built in place, stashed, or handed off. */
+    readonly BUILD_REQUIRED: "dropzone_build_required";
+    /** A static deploy went live (anonymous or into the visitor's account). */
+    readonly DEPLOY_SUCCEEDED: "dropzone_deploy_succeeded";
+    /** A build was enqueued in the visitor's account. */
+    readonly BUILD_DEPLOY_SUCCEEDED: "dropzone_build_deploy_succeeded";
+    /** Any attempt ended in an error (including a failed resume). */
+    readonly DEPLOY_FAILED: "dropzone_deploy_failed";
+    /** A logged-out build drop was stashed locally before the signup hand-off. */
+    readonly PROJECT_STASHED: "dropzone_project_stashed";
+    /** A stashed build drop was picked up for automatic deployment. */
+    readonly RESUMED: "dropzone_resumed";
+};
+export type DropZoneEventName = (typeof DROPZONE_EVENTS)[keyof typeof DROPZONE_EVENTS];
+/** Properties the component adds to every event. */
+export interface DropZoneBaseEventProps {
+    /** Present when the consumer sets `analyticsId` — tells multiple zones apart. */
+    dropzone_id?: string;
+}
+export interface FilesDroppedProps extends DropZoneBaseEventProps {
+    method: 'drag';
+    file_count: number;
+    /** Omitted — never `[]` — when the browser exposes no files. */
+    file_types?: string[];
+}
+export interface BrowseOpenedProps extends DropZoneBaseEventProps {
+    method: 'keyboard' | 'click';
+}
+export interface BuildRequiredProps extends DropZoneBaseEventProps {
+    method: DropMethod;
+    reason: BuildReason | null;
+    file_count: number;
+    file_types?: string[];
+}
+export interface DeploySucceededProps extends DropZoneBaseEventProps {
+    method: DropMethod;
+    site_name: string;
+    file_count: number;
+    /** Whether the deploy landed directly in the visitor's account. */
+    authenticated: boolean;
+    /** Present only when an authenticated attempt bounced (stale login hint) and the drop completed anonymously. */
+    auth_fallback?: true;
+    file_types?: string[];
+}
+export interface BuildDeploySucceededProps extends DropZoneBaseEventProps {
+    method: DropMethod;
+    reason: BuildReason | null;
+    site_name: string;
+    file_count: number;
+    /** Present when build settings were synthesised into the archive. */
+    framework?: string;
+    file_types?: string[];
+}
+export interface DeployFailedProps extends DropZoneBaseEventProps {
+    /** Absent when the failure comes from a stash resume rather than a live drop gesture. */
+    method?: DropMethod;
+    /** Raw failure reason (e.g. "drop failed: 429", "resume_failed") — the humanized copy goes to the UI, not here. */
+    reason: string;
+    /** Present only when the file set is known (absent when reading itself threw). */
+    file_count?: number;
+    file_types?: string[];
+}
+export interface ProjectStashedProps extends DropZoneBaseEventProps {
+    method: DropMethod;
+    reason: BuildReason | null;
+    file_count: number;
+    file_types?: string[];
+}
+/** A resume starts from storage, not a fresh gesture — no method or file set to report. */
+export type ResumedProps = DropZoneBaseEventProps;
+/** Event name → its property shape, for typed emitters and sinks on either side of the seam. */
+export interface DropZoneEventProperties {
+    dropzone_files_dropped: FilesDroppedProps;
+    dropzone_browse_opened: BrowseOpenedProps;
+    dropzone_build_required: BuildRequiredProps;
+    dropzone_deploy_succeeded: DeploySucceededProps;
+    dropzone_build_deploy_succeeded: BuildDeploySucceededProps;
+    dropzone_deploy_failed: DeployFailedProps;
+    dropzone_project_stashed: ProjectStashedProps;
+    dropzone_resumed: ResumedProps;
+}
+/**
+ * Provider-agnostic analytics sink. Deliberately loose (string, not the event
+ * union): hosts forward these to Segment/GA/GTM and often pipe their own
+ * events through the same function.
+ */
+export type TrackFn = (event: string, properties?: Record<string, unknown>) => void;

package/dist/drop-core/analytics.js

@@ -0,0 +1,21 @@
+const e = {
+  /** Files arrived via drag — the picker path reports its files on outcome events instead. */
+  FILES_DROPPED: "dropzone_files_dropped",
+  /** The native file picker was opened (keyboard or click). */
+  BROWSE_OPENED: "dropzone_browse_opened",
+  /** The drop needs a build — it will be built in place, stashed, or handed off. */
+  BUILD_REQUIRED: "dropzone_build_required",
+  /** A static deploy went live (anonymous or into the visitor's account). */
+  DEPLOY_SUCCEEDED: "dropzone_deploy_succeeded",
+  /** A build was enqueued in the visitor's account. */
+  BUILD_DEPLOY_SUCCEEDED: "dropzone_build_deploy_succeeded",
+  /** Any attempt ended in an error (including a failed resume). */
+  DEPLOY_FAILED: "dropzone_deploy_failed",
+  /** A logged-out build drop was stashed locally before the signup hand-off. */
+  PROJECT_STASHED: "dropzone_project_stashed",
+  /** A stashed build drop was picked up for automatic deployment. */
+  RESUMED: "dropzone_resumed"
+};
+export {
+  e as DROPZONE_EVENTS
+};

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

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

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

@@ -0,0 +1,55 @@
+import { BuildSite } from './types';
+/**
+ * The transport both authenticated clients share: JSON calls ride the
+ * consumer's access-control rewrite on the session cookie, so nothing
+ * credential-shaped lives in the browser and nothing can expire mid-deploy.
+ * (Uploads are the exception — the proxy's Lambda caps request bodies at
+ * ~6MB — and each client handles its own, bearer-authorized.)
+ */
+/**
+ * Default root for proxied JSON calls. On netlify.com the `/access-control/*`
+ * rewrite targets the app's access-control function, making this path the API
+ * root. The paths a given 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 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;
+/**
+ * Create a site in the visitor's account via `POST {proxyBase}/sites` (scoped
+ * to `accountSlug` when given, else the user's default account), attributed
+ * `created_via: 'drop'`.
+ *
+ * A logged-out visitor 401s here, before anything is created — the one
+ * pre-mutation point where callers may still safely fall back to an anonymous
+ * flow, which is why it maps to `NotAuthenticatedError`. Any other failure is
+ * a `SiteCreateError` carrying the status.
+ */
+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';
+};
+/**
+ * Poll `GET {proxyBase}/deploys/{deployId}` on the session cookie until the
+ * deploy settles, and report how. Purely mechanical on purpose: each caller
+ * maps the outcome onto its own error vocabulary (the drop client throws plain
+ * errors `humanizeDropError` understands; the build client throws
+ * `BuildFailedError`/`BuildTimeoutError`), so that knowledge stays next to the
+ * class it belongs to.
+ *
+ * A non-ok poll response is skipped, not fatal — a transient proxy hiccup
+ * shouldn't kill a deploy that is still progressing.
+ */
+export declare function pollDeployUntilSettled(options: {
+    proxyBase: string;
+    deployId: string;
+    pollIntervalMs: number;
+    timeoutMs: number;
+}): Promise<SettledDeploy>;

package/dist/drop-core/authedApi.js

@@ -0,0 +1,35 @@
+import { NotAuthenticatedError as d, SiteCreateError as l } from "./errors.js";
+const f = "/access-control/bb-api/api/v1", y = "https://api.netlify.com/api/v1", T = 1e3, m = 10 * 60 * 1e3;
+async function A(s, o) {
+  const r = o ? `/${o}/sites` : "/sites", t = await fetch(`${s}${r}`, {
+    method: "POST",
+    credentials: "include",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ created_via: "drop" })
+  });
+  if (t.status === 401 || t.status === 403) throw new d();
+  if (!t.ok) throw new l(t.status);
+  return t.json();
+}
+const p = /* @__PURE__ */ new Set(["ready", "error", "rejected"]);
+async function E(s) {
+  const { proxyBase: o, deployId: r, pollIntervalMs: t, timeoutMs: i } = s, c = i / t;
+  for (let n = 0; n < c; n++) {
+    const a = await fetch(`${o}/deploys/${r}`, { credentials: "include" });
+    if (a.ok) {
+      const e = await a.json();
+      if (e.state && p.has(e.state))
+        return e.state === "ready" ? { outcome: "ready" } : { outcome: "failed", errorMessage: e.error_message };
+    }
+    await new Promise((e) => setTimeout(e, t));
+  }
+  return { outcome: "timed-out" };
+}
+export {
+  y as DEFAULT_API_BASE,
+  T as DEFAULT_POLL_INTERVAL_MS,
+  f as DEFAULT_PROXY_BASE,
+  m as DEFAULT_TIMEOUT_MS,
+  A as createSiteInAccount,
+  E as pollDeployUntilSettled
+};

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

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