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

package/README.md

@@ -147,13 +147,13 @@ This repo includes a [Claude Code](https://claude.ai/code) skill for generating
 
 The skill is available automatically. Run:
 
-```text
+```
 /project:landing-page <describe the page you want>
 ```
 
 For example:
 
-```text
+```
 /project:landing-page A landing page for a new enterprise hosting product with a hero, feature cards, and a pricing comparison
 ```
 
@@ -185,7 +185,7 @@ When you’re ready to validate your component changes in a deploy preview, you
 >
 > Reach out to #internal-permissions in Slack
 
-### Steps to Publish an Alpha Release
+### Steps to Publish an Alpha Release:
 
 1. **Make sure you're logged into npm locally**
 
@@ -206,7 +206,6 @@ When you’re ready to validate your component changes in a deploy preview, you
    ```
 
 1. **Install the updated package:**
-
    ```bash
    npm install
    ```

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

@@ -10,29 +10,17 @@ interface Props {
     client?: DropClient;
     /** Build the "claim this site" URL from the assigned site name (subdomain). */
     claimUrl?: (siteName: string) => string;
-    /**
-     * Where an authenticated static deploy sends the visitor — the site already
-     * lives in their account, so there is no claim step. Defaults to the new
-     * site's project overview on app.netlify.com.
-     */
+    /** Destination after an authenticated static deploy (no claim step). Default: the project overview. */
     siteDashboardUrl?: (siteName: string) => string;
     /**
-     * The signup hand-off for a build-required drop that can't be built here (no
-     * session, or no build wiring). The drop is stashed on this origin first, so
-     * a flow that returns the visitor to this page deploys it automatically —
-     * see `resumeStashedBuilds`. Defaults to the app signup page with
-     * `next=/drop`.
+     * Signup hand-off for a build drop with no session. The drop is stashed on
+     * this origin first — return the visitor here and it deploys automatically.
      */
     buildSignupUrl?: string;
     /**
-     * Mint a short-lived bearer token for direct api.netlify.com uploads — pass it
-     * to switch on the whole authenticated path for logged-in visitors: static
-     * drops deploy straight into their account (then `siteDashboardUrl`), and
-     * build-required drops build in place instead of being handed off to the app.
-     * On netlify.com this reads `GET /access-control/generate-access-control-token`.
-     * Resolving `null` means "no session": static drops fall back to the anonymous
-     * claim flow; build drops are stashed and handed to `buildSignupUrl`.
-     * See [Logged-in visitors](#logged-in-visitors).
+     * Mint the upload bearer — passing this switches on the whole authenticated
+     * path. `null` means "no session": static drops fall back to the anonymous
+     * claim flow; build drops stash and hand off. See the docs' Logged-in visitors.
      */
     getUploadToken?: () => Promise<string | null>;
     /**
@@ -40,111 +28,49 @@ interface Props {
      * Takes precedence over `getUploadToken` for the build path.
      */
     buildClient?: BuildClient;
-    /**
-     * Inject a custom authenticated `DropClient` for static drops (tests, staging,
-     * a different account flow). Takes precedence over `getUploadToken` for the
-     * static path. Distinct from `client`, which is the anonymous fallback.
-     */
+    /** Custom authenticated static-drop client; wins over `getUploadToken`. (`client` is the anonymous fallback.) */
     authenticatedDropClient?: DropClient;
-    /**
-     * API root for the authenticated paths' JSON calls, which go through your
-     * access-control rewrite so the session cookie authorizes them. Defaults to
-     * `/access-control/bb-api/api/v1`. (Uploads always go direct to
-     * `api.netlify.com` — the proxy can't carry bodies that large.)
-     */
+    /** Root for the session-cookie JSON calls, via your access-control rewrite. Uploads always go direct. */
     proxyBase?: string;
     /** Create the visitor's new project in this account. Omit for their default account. */
     accountSlug?: string;
-    /**
-     * Where an enqueued build sends the visitor. Defaults to the new site's
-     * project overview, same as a static deploy; `build.deployId` is available for
-     * consumers who want the deploy-log page instead.
-     */
+    /** Destination after a build is enqueued. Default: the project overview (`build.deployId` for the logs page). */
     buildDeployUrl?: (build: DeployedBuild) => string;
     /**
-     * Poll until the build finishes before handing off, instead of redirecting as
-     * soon as it's enqueued. The trade-off: waiting means a failing build surfaces
-     * its own error message here (via `onError` and the overlay) rather than the
-     * visitor discovering it on the deploy page — at the cost of holding them on a
-     * spinner for the length of the build, which is minutes. Off by default.
+     * Hold the visitor until the build finishes (off by default — builds take
+     * minutes). On is the only way a failing build's own message reaches `onError`.
      */
     waitForBuild?: boolean;
-    /**
-     * Called when a build-required drop is detected, instead of building it or
-     * redirecting. Use it to own the hand-off yourself (custom routing, persisting
-     * the drop, gating on auth). When set, the component neither builds nor
-     * redirects. The static drop path is unaffected either way.
-     */
+    /** Take over build-required drops entirely — when set, the component neither builds nor redirects. */
     onBuildRequired?: (info: BuildDetection) => void;
     /**
-     * Called instead of the `buildSignupUrl` redirect when a build-required drop
-     * can't be built here (no session). By this point the drop has been stashed
-     * on this origin (`stashed` says whether that succeeded) — own the hand-off
-     * however fits your auth flow, e.g. open a signup popup that keeps the
-     * visitor on the page. Once they're back authenticated, a remount of the
-     * zone deploys the stash automatically.
+     * Own the signup hand-off instead of the `buildSignupUrl` redirect (e.g. an
+     * auth popup). The drop is already stashed; a remount while authenticated
+     * deploys it.
      */
     onBuildSignupHandoff?: (info: {
         stashed: boolean;
         detection: BuildDetection;
     }) => void;
-    /**
-     * Deploy a previously stashed build drop automatically when the zone mounts
-     * with an authenticated visitor (default `true`). The stash is written when a
-     * logged-out build drop is handed to signup; see
-     * [Signup hand-off and auto-resume](#signup-hand-off-and-auto-resume).
-     */
+    /** Auto-deploy a stashed build drop on mount when authenticated (default true). */
     resumeStashedBuilds?: boolean;
     /** Called once the deploy is live. */
     onDeploy?: (result: DeployedSite) => void;
-    /**
-     * Called once a build-required drop has been zipped, uploaded and enqueued —
-     * before the redirect to `buildDeployUrl`. The site exists at this point but
-     * won't serve content until the build finishes.
-     */
+    /** Called once a build is enqueued, before the `buildDeployUrl` redirect. */
     onBuildDeploy?: (build: DeployedBuild) => void;
-    /**
-     * Called when a deploy fails, with a humanized `message` (ready to show a
-     * user — the same copy the built-in overlay uses) and the raw `reason`. Pair
-     * this with `showStatus={false}` to render your own error UI.
-     */
+    /** Deploy failures: humanized `message` (the overlay's copy) + raw `reason`. Pair with showStatus={false}. */
     onError?: (error: DeployError) => void;
     /**
-     * Render the built-in status overlay (drag tint, spinner, progress bar, error).
-     * Set to `false` to suppress it entirely and keep your children visible, then
-     * drive your own feedback from the `data-state` attribute on the root element.
-     * Note: in this mode you're responsible for surfacing errors yourself — use
-     * `onError` to get the message.
+     * Render the built-in overlay. `false` keeps children visible — drive your
+     * own feedback from `data-state`, and surface errors yourself via `onError`.
      */
     showStatus?: boolean;
     /**
-     * Analytics hook. Called at each tracked moment with an event name and
-     * properties. Stays provider-agnostic — wire it to Segment/Amplitude/GA in the
-     * consuming app, e.g. `onTrack={(name, props) => new Analytics().track(name, props)}`.
-     * Emitted events (all include `dropzone_id` when `analyticsId` is set):
-     * - `dropzone_files_dropped`  — files dropped via drag  ({ method: 'drag', file_count, file_types })
-     * - `dropzone_browse_opened`  — file picker opened       ({ method: 'keyboard' | 'click' })
-     * - `dropzone_build_required` — drop needs a build (built here, or handed off) ({ method, reason, file_count, file_types })
-     * - `dropzone_deploy_succeeded` — static deploy went live ({ method, site_name, file_count, authenticated, auth_fallback?, file_types })
-     * - `dropzone_build_deploy_succeeded` — build enqueued for a logged-in visitor ({ method, reason, site_name, file_count, framework?, file_types })
-     * - `dropzone_deploy_failed`  — deploy or build errored out ({ method, reason, file_count?, file_types })
-     *
-     * `authenticated` says whether the deploy landed in the visitor's account;
-     * `auth_fallback: true` is sent only when an authenticated attempt bounced
-     * (stale auth hint) and the drop completed anonymously — omitted otherwise.
-     * `file_types` is the sorted, de-duplicated list of MIME types in the
-     * selection, with `application/octet-stream` standing in wherever the browser
-     * reports none (a dragged folder, an `.exe`). It is omitted when the browser
-     * exposes no files at all. Note `dropzone_files_dropped` only fires for drag —
-     * a file-picker selection reports its types on the outcome events, as
-     * `dropzone_browse_opened` fires before any file exists.
+     * Provider-agnostic analytics hook. Event names and payload shapes live in
+     * DROPZONE_EVENTS / DropZoneEventProperties (drop-core/analytics.ts).
      */
     onTrack?: TrackFn;
-    /**
-     * Stable identifier for this instance, attached to every tracked event as
-     * `dropzone_id`. Set it when a page renders more than one Drop Zone so the
-     * events can be told apart in Amplitude.
-     */
+    /** Stamped on every event as `dropzone_id` — set when a page has more than one zone. */
     analyticsId?: string;
     className?: string;
 }

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

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

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

@@ -1,17 +1,10 @@
 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.
- */
+/** The analytics contract: canonical event names + property shapes, so no consumer hand-writes them. */
 /** 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.
+ * The wire names. Amplitude/Segment history keys off these exact strings —
+ * append-only, never rename.
  */
 export declare const DROPZONE_EVENTS: {
     /** Files arrived via drag — the picker path reports its files on outcome events instead. */
@@ -99,9 +92,5 @@ export interface DropZoneEventProperties {
     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.
- */
+/** Provider-agnostic sink — loose on purpose, since hosts pipe their own events through it too. */
 export type TrackFn = (event: string, properties?: Record<string, unknown>) => void;

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

@@ -1,20 +1,13 @@
 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.)
+ * Transport shared by both authenticated clients: JSON rides the consumer's
+ * access-control rewrite on the session cookie. Uploads are each client's own
+ * (bearer-direct — the proxy can't carry them).
  */
 /**
- * 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.
+ * `POST {proxyBase}/sites`, attributed `created_via: 'drop'`. A logged-out
+ * visitor 401s here, before anything is created — the one point an anonymous
+ * fallback is still safe, hence NotAuthenticatedError.
  */
 export declare function createSiteInAccount(proxyBase: string, accountSlug?: string): Promise<BuildSite>;
 /** How a watched deploy ended. `errorMessage` is the API's own explanation, when it gave one. */
@@ -27,15 +20,9 @@ export type SettledDeploy = {
     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.
+ * Polls the deploy on the session cookie and reports the terminal outcome —
+ * callers map it onto their own error vocabulary. Non-ok reads are skipped,
+ * not fatal: a proxy hiccup shouldn't kill a progressing deploy.
  */
 export declare function pollDeployUntilSettled(options: {
     proxyBase: string;