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

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

@@ -2,23 +2,15 @@ import { ProcessedFile } from './types';
 /** Why a drop was judged to need a build — surfaced to analytics and `onBuildRequired`. */
 export type BuildReason = 'netlify-toml-build' | 'package-json-build-script' | 'framework-dependency' | 'functions-directory';
 export interface BuildDetection {
-    /** True when the dropped project needs a build step and can't be served as static files. */
+    /** The drop can't be served as static files. */
     buildRequired: boolean;
     /** The signal that decided it (first match wins), or null for a plain static drop. */
     reason: BuildReason | null;
 }
 /**
- * Decide whether a dropped project needs a build. Runs on the already-read,
- * root-normalized `ProcessedFile[]` (a dropped `.zip` is expanded and the common
- * root folder stripped upstream in `readFiles`), so build config sits at the
- * deploy root, e.g. `/netlify.toml`, `/package.json`.
- *
- * The anonymous drop API only performs static deploys, so a build-required
- * project can't go through it — the consumer redirects such drops to the
- * authenticated Drop page instead. This heuristic is deliberately lightweight
- * (no framework-detection dependency): it reads the two config files and looks
- * for the zero-config functions directories. A plain static site (HTML/CSS/JS,
- * no build config) returns `{ buildRequired: false }`.
+ * Does this drop need a build? Deliberately lightweight (two config files +
+ * the functions dirs; no framework-detection dependency). Input is
+ * root-normalized by `readFiles`, so config sits at `/netlify.toml` etc.
  */
 export declare function detectBuild(files: ProcessedFile[]): BuildDetection;
 /** Build settings confident enough to write into a `netlify.toml` for buildbot. */
@@ -31,19 +23,9 @@ export interface InferredBuildSettings {
     framework: string;
 }
 /**
- * Infer the build command and publish directory for a build-required drop, so
- * `zipFiles` can write them into a `netlify.toml` that buildbot reads.
- *
- * Deliberately conservative: it returns settings **only** when both halves are
- * known — a `build` script (which gives the command) and a recognised framework
- * with a fixed default publish directory (which gives the output). Anything else
- * returns `null`, leaving the zip without a synthesised `[build]` table so
- * buildbot's own framework detection resolves the settings instead. That matters
- * because a `[build]` table with a command but no `publish` makes buildbot
- * publish the deploy root — shipping the project's *source* rather than its
- * built output, which is worse than not guessing at all.
- *
- * Returns `null` too when the drop already declares a `[build]` table: the
- * author's own config always wins.
+ * Build settings for the synthesised netlify.toml — only when BOTH halves are
+ * known (build script → command, known framework → publish). Guessing publish
+ * wrong ships source instead of output, so `null` beats a bad guess. An
+ * author-declared [build] table always wins (also `null`).
  */
 export declare function inferBuildSettings(files: ProcessedFile[]): InferredBuildSettings | null;

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

@@ -1,33 +1,22 @@
 /**
- * Thrown when the user drops or picks a single loose file that Drop can't turn
- * into a site on its own — anything that isn't a `.zip` (a site archive) or an
- * HTML page (served as index.html). A folder, multiple files, a zip, or a lone
- * HTML file are all fine; any other single file is rejected rather than
- * deployed as a one-asset site (matches react-ui).
+ * A single loose file that can't stand up a site — only a zip, folder,
+ * multiple files, or a lone HTML page may deploy (matches react-ui).
  */
 export declare class UnsupportedDropError extends Error {
     readonly code = "unsupported-drop";
     constructor();
 }
 /**
- * Thrown when an authenticated path (static or build) turns out to have no
- * usable session — the short-lived upload token came back empty, or the
- * session-cookie site create was refused, so nothing was created. For static
- * drops the flow falls back to the anonymous drop + claim; builds have no
- * anonymous equivalent, so the consumer's only recourse is to send the visitor
- * through login/signup and have them drop again.
+ * The pre-mutation "no session" signal: nothing was created yet, so static
+ * drops may fall back to the anonymous flow and build drops stash + hand off.
  */
 export declare class NotAuthenticatedError extends Error {
     readonly code = "not-authenticated";
     constructor(message?: string);
 }
 /**
- * Whether an error is the pre-mutation "no session" signal, however it
- * traveled. This package ships as both raw TypeScript (`./components`) and
- * compiled dist (`./preact`, `./drop-core`), so two copies of the class can
- * coexist in one app and defeat `instanceof` — the `code` brand is the
- * copy-proof fallback. Control flow that decides whether an anonymous retry
- * is safe must use this, never a bare `instanceof`.
+ * Copy-proof check for the "no session" error — `instanceof` misses class
+ * copies from the package's other entrypoint. Fallback gates must use this.
  */
 export declare function isNotAuthenticatedError(err: unknown): err is NotAuthenticatedError;
 /** `POST …/sites` failed, so there is nothing to build into. Carries the HTTP status. */
@@ -45,12 +34,7 @@ export declare class BuildCreateError extends Error {
     status?: number;
     constructor(status?: number);
 }
-/**
- * The build ran and ended in `error`/`rejected`. `reason` is the API's
- * `error_message` when there is one — it's the only part of a build failure that
- * says anything actionable (a failing build command, a missing dependency), so
- * it is surfaced to the user rather than swallowed.
- */
+/** The build ran and broke. `reason` carries the API's `error_message` — the only actionable part. */
 export declare class BuildFailedError extends Error {
     reason?: string | undefined;
     readonly code = "build-failed";
@@ -61,10 +45,7 @@ export declare class BuildTimeoutError extends Error {
     readonly code = "build-timeout";
     constructor();
 }
-/**
- * A static deploy ran and ended in `error`/`rejected`. Like a build failure,
- * the API's `error_message` is the actionable part, so it travels on the error.
- */
+/** A static deploy ran and ended in `error`/`rejected`; `reason` carries the API's `error_message`. */
 export declare class DeployFailedError extends Error {
     reason?: string | undefined;
     readonly code = "deploy-failed";

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

@@ -1,17 +1,7 @@
 /**
- * Distinct MIME types across a drop or file-picker selection, sorted so the same
- * selection always yields the same array.
- *
- * Read from the raw `File.type` at the drop boundary rather than from
- * `ProcessedFile`s: the MIME type only exists on the original `File`, and reading
- * can throw before any `ProcessedFile` does (an unsupported single file) — the
- * very case the file type is most worth knowing about.
- *
- * Browsers leave `File.type` empty for anything they don't recognise — a dragged
- * folder, an `.exe`, an extensionless file — so those collapse to
- * `application/octet-stream` and the property never carries an empty string.
- *
- * Call this synchronously inside the drop handler: a `DataTransfer` detaches once
- * the event turn ends.
+ * Distinct, sorted MIME types of a selection. Read at the drop boundary — the
+ * type only exists on the original File, and reading can throw before any
+ * ProcessedFile exists. Call synchronously in the drop handler: a DataTransfer
+ * detaches after the event turn.
  */
 export declare function getFileTypes(files: FileList | null | undefined): string[];

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

@@ -1,21 +1,15 @@
 import { ProcessedFile } from './types';
 /**
- * Read a DataTransfer from a drop event into ProcessedFiles.
- *
- * NOTE: `webkitGetAsEntry()` must be called synchronously inside the drop
- * handler — the DataTransfer is detached once the event turn ends. The
- * component captures entries first (see `readDroppedEntries`) then calls the
- * async readers, so this function is safe to `await`.
+ * Read a drop's DataTransfer into ProcessedFiles. `webkitGetAsEntry()` runs
+ * synchronously before the first await — the DataTransfer detaches once the
+ * event turn ends.
  */
 export declare function readDataTransfer(dt: DataTransfer): Promise<ProcessedFile[]>;
 export declare function readFileList(files: FileList): Promise<ProcessedFile[]>;
 export declare function getSingleNonIndexHtmlFileName(files: ProcessedFile[]): string | null;
 export declare function hasMultipleHtmlFilesWithoutIndex(files: ProcessedFile[]): boolean;
 /**
- * When the set has no index.html but exactly one HTML file (a lone page
- * alongside its assets, or a single dropped file), rename that file to
- * index.html — keeping its directory — so it is served at the site root
- * instead of 404ing. Content and sha are untouched. Any other set (already has
- * an index, multiple HTML files, or no HTML) is returned unchanged.
+ * A lone non-index HTML page is renamed to index.html (same directory,
+ * content/sha untouched) so it serves instead of 404ing. Other sets unchanged.
  */
 export declare function renameSingleNonIndexHtmlToIndex(files: ProcessedFile[]): ProcessedFile[];

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

@@ -9,10 +9,8 @@ export interface ProcessedFile {
 }
 export type Digest = Record<string, string>;
 /**
- * Response body of `POST /api/v1/drop`. Not a canonical Deploy resource —
- * it's a mixed shape carrying both the anonymous site and the initial deploy
- * so the client has everything it needs to upload, poll, and hand off to the
- * user in one round trip.
+ * Response of `POST /api/v1/drop` — a mixed site+deploy shape, everything the
+ * client needs to upload, poll, and hand off in one round trip.
  */
 export interface DropResponse {
     /** site id (UUID) — surfaced to callers so they can build claim links */

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

@@ -1,46 +1,23 @@
 import { InferredBuildSettings } from './detectBuild';
 import { ProcessedFile } from './types';
-/**
- * Render inferred settings as a `[build]` table. Only `command` and `publish`
- * are written: everything else (functions directory, plugins, node version)
- * is zero-config on Netlify's side and guessing at it would override detection
- * that is better informed than we are.
- */
+/** Renders a [build] table — command and publish only; everything else is zero-config server-side. */
 export declare function generateNetlifyToml({ command, publish }: InferredBuildSettings): string;
 export interface ZipOptions {
     /** Filename given to the produced `File`. Shows up as the build's source archive. */
     name?: string;
-    /**
-     * Synthesise a `netlify.toml` `[build]` table from `inferBuildSettings` when the
-     * drop doesn't declare one (default `true`). Set `false` to upload the files
-     * exactly as dropped and let buildbot resolve every setting itself.
-     */
+    /** Synthesise a [build] table when the drop lacks one (default true); false uploads as-dropped. */
     synthesizeNetlifyToml?: boolean;
 }
 export interface ZipResult {
     /** The archive, ready to hand to `createBuildFromZip`. */
     file: File;
-    /**
-     * The settings written into `netlify.toml`, or `null` when the archive is a
-     * faithful copy of the drop — either because it already declared a `[build]`
-     * table, or because nothing could be inferred with confidence.
-     */
+    /** Settings written into netlify.toml, or null when the archive is a faithful copy. */
     buildSettings: InferredBuildSettings | null;
 }
 /**
- * Zip an already-read file set into the source archive that
- * `POST /sites/{id}/builds` expects.
- *
- * The input is the same root-normalized `ProcessedFile[]` the static deploy path
- * uses (see `readFiles`), so junk — dotfiles, `node_modules`, macOS metadata — is
- * already gone and paths sit at the deploy root. Output directories (`dist/`,
- * `build/`) are deliberately *not* stripped: buildbot regenerates them when
- * there's a build command, and a drop whose `netlify.toml` publishes a committed
- * directory without a command would break if we removed it.
- *
- * When the drop needs a build but declares no `[build]` table, an inferred one is
- * written in (appended to an existing `netlify.toml`, or created if there is
- * none) so buildbot doesn't publish the project's source. See
- * `inferBuildSettings` for how conservative that inference is.
+ * Zip a read file set into the archive `POST /sites/{id}/builds` expects.
+ * Junk is already gone (readFiles); dist/build are deliberately kept — a drop
+ * publishing a committed directory without a command would break without them.
+ * A [build] table is synthesised when missing (appended, so redirects survive).
  */
 export declare function zipFiles(files: ProcessedFile[], { name, synthesizeNetlifyToml }?: ZipOptions): Promise<ZipResult>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@netlify/spark-ui",
   "description": "Assets, design tokens, components, and utilities",
-  "version": "1.31.0-alpha.5",
+  "version": "1.31.0-alpha.7",
   "type": "module",
   "main": "dist/components/preact/index.js",
   "types": "dist/components/preact/index.d.ts",

package/packages/components/preact/DropZone/DropZone.tsx

@@ -25,26 +25,13 @@ const DRAG_INACTIVE_MS = 120;
 
 const defaultClaimUrl = (siteName: string) => `https://app.netlify.com/drop/${siteName}`;
 
-/**
- * Where an authenticated static deploy lands: the new site's project overview,
- * the same place the app's own logged-in drop sends you.
- */
+/** The project overview — where the app's own logged-in drop lands too. */
 const defaultSiteDashboardUrl = (siteName: string) =>
   `https://app.netlify.com/projects/${siteName}`;
 
-/**
- * Where a build-required drop is sent by default. Mirrors the app's own Drop
- * page: signup with `next=/drop`, so after signup + email verification the user
- * lands back on the authenticated Drop page and can build there.
- */
+// Mirrors the app's own Drop page hand-off.
 const defaultBuildSignupUrl = 'https://app.netlify.com/signup?next=/drop&utm_campaign=drop';
 
-/**
- * Where an authenticated build drop lands: the new site's project overview —
- * the same destination as a static deploy, and where the app's own Drop page
- * sends build drops. The overview surfaces the in-progress deploy; consumers
- * who want the deploy-log page instead can override with `build.deployId`.
- */
 const defaultBuildDeployUrl = ({ siteName }: DeployedBuild) =>
   `https://app.netlify.com/projects/${siteName}`;
 
@@ -57,29 +44,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>;
   /**
@@ -87,108 +62,46 @@ 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;
 }
@@ -218,8 +131,6 @@ export default function DropZone({
   analyticsId,
   className,
 }: Props) {
-  // Tag every event with this instance's id so multiple zones on a page can be
-  // told apart, then hand it off to the consumer's analytics.
   const track: TrackFn = (event, properties = {}) =>
     onTrack?.(event, analyticsId ? { dropzone_id: analyticsId, ...properties } : properties);
 
@@ -253,8 +164,6 @@ export default function DropZone({
     inputRef.current?.click();
   };
 
-  // The overlay only paints when there's something to show — dragging, deploying,
-  // or an error. With `showStatus` off, the consumer drives their own feedback.
   const showOverlay = showStatus && (active || busy || status.kind === 'error');
   const rootClass = [
     'n-dropzone',
@@ -343,11 +252,8 @@ export default function DropZone({
 }
 
 /**
- * Track whether a drag is currently over the zone. A drag has no reliable
- * "cancelled" event — pressing Escape or dropping elsewhere just stops the
- * stream of `dragover` events — so we stay active only while they keep arriving
- * and clear shortly after they stop. This also handles drags over children,
- * where `dragleave` targets a child rather than the zone.
+ * Drag-over tracking by dragover decay: drags have no reliable cancel event,
+ * and dragleave targets children — so stay active while events keep arriving.
  */
 function useDragActive() {
   const [active, setActive] = useState(false);

package/packages/components/preact/DropZone/useDropDeploy.test.ts

@@ -287,6 +287,18 @@ describe('build-required drops', () => {
 
     expect(saveDropStash).not.toHaveBeenCalled();
     expect(harness.assigned).toEqual(['https://app.netlify.com/signup?next=/drop']);
+    // Nothing was stashed, so the drop is lost rather than deferred — reported
+    // with the same reason react-ui uses for its own build bounce.
+    const failed = harness.events.find(e => e.event === DROPZONE_EVENTS.DEPLOY_FAILED);
+    expect(failed?.props).toMatchObject({ reason: 'anonymous_build_not_supported' });
+  });
+
+  it('does not report a loss when the archive was stashed', async () => {
+    const harness = mountHook({ buildClient: makeBuildClient('no-auth'), getUploadToken: async () => null });
+    await harness.api.deploy(async () => buildFiles(), 'drag', []);
+    await settle();
+
+    expect(harness.events.map(e => e.event)).not.toContain(DROPZONE_EVENTS.DEPLOY_FAILED);
   });
 
   it('cedes everything to onBuildRequired when set', async () => {