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

package/packages/{components/preact/DropZone/drop-core → drop-core}/errors.ts

@@ -6,6 +6,8 @@
  * deployed as a one-asset site (matches react-ui).
  */
 export class UnsupportedDropError extends Error {
+  readonly code = 'unsupported-drop';
+
   constructor() {
     super('unsupported single file');
     this.name = 'UnsupportedDropError';
@@ -21,14 +23,30 @@ export class UnsupportedDropError extends Error {
  * through login/signup and have them drop again.
  */
 export class NotAuthenticatedError extends Error {
+  readonly code = 'not-authenticated';
+
   constructor(message = 'not authenticated') {
     super(message);
     this.name = 'NotAuthenticatedError';
   }
 }
 
+/**
+ * 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`.
+ */
+export function isNotAuthenticatedError(err: unknown): err is NotAuthenticatedError {
+  if (err instanceof NotAuthenticatedError) return true;
+  return err instanceof Error && (err as { code?: string }).code === 'not-authenticated';
+}
+
 /** `POST …/sites` failed, so there is nothing to build into. Carries the HTTP status. */
 export class SiteCreateError extends Error {
+  readonly code = 'site-create-failed';
   status?: number;
 
   constructor(status?: number) {
@@ -43,6 +61,7 @@ export class SiteCreateError extends Error {
  * started. Distinct from `BuildFailedError`, which is a build that ran and broke.
  */
 export class BuildCreateError extends Error {
+  readonly code = 'build-create-failed';
   status?: number;
 
   constructor(status?: number) {
@@ -59,6 +78,8 @@ export class BuildCreateError extends Error {
  * it is surfaced to the user rather than swallowed.
  */
 export class BuildFailedError extends Error {
+  readonly code = 'build-failed';
+
   constructor(public reason?: string) {
     super(reason ? `build failed: ${reason}` : 'build failed');
     this.name = 'BuildFailedError';
@@ -67,12 +88,37 @@ export class BuildFailedError extends Error {
 
 /** The build hadn't settled before the poller gave up. The build itself may still finish. */
 export class BuildTimeoutError extends Error {
+  readonly code = 'build-timeout';
+
   constructor() {
     super('Build did not finish in time');
     this.name = 'BuildTimeoutError';
   }
 }
 
+/**
+ * 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.
+ */
+export class DeployFailedError extends Error {
+  readonly code = 'deploy-failed';
+
+  constructor(public reason?: string) {
+    super(reason ? `deploy failed: ${reason}` : 'deploy failed');
+    this.name = 'DeployFailedError';
+  }
+}
+
+/** The deploy hadn't gone ready before the poller gave up. It may still finish. */
+export class DeployTimeoutError extends Error {
+  readonly code = 'deploy-timeout';
+
+  constructor() {
+    super('Deploy did not become ready in time');
+    this.name = 'DeployTimeoutError';
+  }
+}
+
 /**
  * Turn a raw deploy failure into copy a non-technical user can act on.
  * The original message is still tracked via analytics — this is only for display.
@@ -80,31 +126,42 @@ export class BuildTimeoutError extends Error {
 export function humanizeDropError(err: unknown): string {
   if (!(err instanceof Error)) return 'Something went wrong. Please try again.';
 
-  if (err instanceof UnsupportedDropError) {
+  // Match on the `code` brand rather than instanceof: raw-TS and dist copies
+  // of these classes can coexist (see isNotAuthenticatedError).
+  const code = (err as { code?: string }).code;
+
+  if (code === 'unsupported-drop') {
     return 'To deploy, drop a folder or a .zip file — or a single HTML page.';
   }
 
-  if (err instanceof NotAuthenticatedError) {
-    return 'Please log in to Netlify to deploy a project that needs a build, then try again.';
+  if (code === 'not-authenticated') {
+    return 'Please log in to Netlify to deploy this project, then try again.';
   }
 
-  if (err instanceof SiteCreateError) {
+  if (code === 'site-create-failed') {
     return "We couldn't create a project for this build. Please try again.";
   }
 
-  // The build's own error message is the only actionable part of a build
-  // failure, so pass it straight through instead of a generic apology.
-  if (err instanceof BuildFailedError) {
-    return err.reason
-      ? `Your build failed: ${err.reason}`
+  // The failure's own error message is the only actionable part, so pass it
+  // straight through instead of a generic apology.
+  if (code === 'build-failed') {
+    const reason = (err as BuildFailedError).reason;
+    return reason
+      ? `Your build failed: ${reason}`
       : 'Your build failed. Check your build settings and try again.';
   }
+  if (code === 'deploy-failed') {
+    const reason = (err as DeployFailedError).reason;
+    return reason
+      ? `Your deploy failed: ${reason}`
+      : 'Your deploy failed. Please try again.';
+  }
 
-  if (err instanceof BuildTimeoutError) {
+  if (code === 'build-timeout') {
     return 'Your build is taking longer than expected. It may still finish — check your Netlify dashboard.';
   }
 
-  if (err.message === 'Deploy did not become ready in time') {
+  if (code === 'deploy-timeout') {
     return 'Your site is taking longer than expected to go live. Please try again in a moment.';
   }
   // fetch() rejects with a TypeError when the network is unreachable (offline, DNS, CORS, etc).

package/packages/drop-core/fileTypes.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { getFileTypes } from './fileTypes';
+
+/** Minimal FileList stand-in — getFileTypes only touches length and iteration. */
+const fileList = (...types: string[]): FileList => {
+  const files = types.map((type, i) => new File(['x'], `f${i}`, { type }));
+  return Object.assign(files, { item: (i: number) => files[i] }) as unknown as FileList;
+};
+
+describe('getFileTypes', () => {
+  it('returns [] when the browser exposes no files', () => {
+    expect(getFileTypes(null)).toEqual([]);
+    expect(getFileTypes(undefined)).toEqual([]);
+    expect(getFileTypes(fileList())).toEqual([]);
+  });
+
+  it('dedupes and sorts so the same selection always yields the same array', () => {
+    expect(getFileTypes(fileList('text/html', 'image/png', 'text/html', 'text/css'))).toEqual([
+      'image/png',
+      'text/css',
+      'text/html',
+    ]);
+  });
+
+  it('reports application/octet-stream for files the browser could not type', () => {
+    // A dragged folder or an .exe arrives with an empty File.type.
+    expect(getFileTypes(fileList(''))).toEqual(['application/octet-stream']);
+  });
+
+  it('caps the list at 20 distinct types', () => {
+    const many = Array.from(
+      { length: 30 },
+      (_, i) => `application/x-${String(i).padStart(2, '0')}`
+    );
+    expect(getFileTypes(fileList(...many))).toHaveLength(20);
+  });
+});

package/packages/drop-core/index.ts

@@ -0,0 +1,44 @@
+/**
+ * The public surface of drop-core — nothing is public unless named here.
+ * `export *` is reserved for the three modules that are contracts in their
+ * entirety: types, errors, and the analytics event map.
+ */
+
+export * from './types';
+export * from './errors';
+export * from './analytics';
+
+// Reading a drop into deployable files
+export {
+  getSingleNonIndexHtmlFileName,
+  hasMultipleHtmlFilesWithoutIndex,
+  readDataTransfer,
+  readFileList,
+  renameSingleNonIndexHtmlToIndex,
+} from './readFiles';
+export { getFileTypes } from './fileTypes';
+
+// Build detection and archive synthesis
+export { detectBuild, inferBuildSettings } from './detectBuild';
+export type { BuildDetection, BuildReason, InferredBuildSettings } from './detectBuild';
+export { zipFiles } from './zip';
+export type { ZipOptions, ZipResult } from './zip';
+
+// Deploy clients — anonymous (claim flow) and authenticated (into the account)
+export { AnonymousDropClient } from './client';
+export type { DropClient } from './client';
+export { AuthenticatedDropClient } from './authedDropClient';
+export type { AuthenticatedDropClientConfig } from './authedDropClient';
+export { AuthenticatedBuildClient } from './buildClient';
+export type { AuthenticatedBuildClientConfig, BuildClient, BuildResponse } from './buildClient';
+
+// Deploy orchestration
+export { deployBuild, deployFiles, deployZippedBuild } from './deploy';
+export type { BuildDeployOptions, BuildDeployResult, DeployOptions } from './deploy';
+
+// Carrying a build drop across the signup round-trip
+export { clearDropStash, hasDropStashMarker, loadDropStash, saveDropStash } from './buildStash';
+export type { DropBuildStash } from './buildStash';
+
+// Documented defaults consumers may want to reference
+export { DEFAULT_API_BASE, DEFAULT_PROXY_BASE, UPLOAD_RETRY_DELAYS_MS } from './constants';

package/packages/drop-core/readFiles.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from 'vitest';
+import { zip } from 'fflate';
+import {
+  getSingleNonIndexHtmlFileName,
+  hasMultipleHtmlFilesWithoutIndex,
+  readFileList,
+  renameSingleNonIndexHtmlToIndex,
+} from './readFiles';
+import { UnsupportedDropError } from './errors';
+import type { ProcessedFile } from './types';
+
+// `readDataTransfer` is deliberately untested: it rides the webkit FileSystem
+// entries API (webkitGetAsEntry / createReader), which no test DOM implements.
+// Its FileList fallback and zip branch share the code paths covered below.
+
+const encoder = new TextEncoder();
+
+const processed = (path: string, name = path.split('/').pop()!): ProcessedFile => ({
+  path,
+  name,
+  size: 1,
+  sha: 'test-sha',
+  content: encoder.encode('x').buffer as ArrayBuffer,
+});
+
+/** A File carrying the relative path a directory-picker <input> would report. */
+const pickedFile = (relativePath: string, contents = 'x'): File => {
+  const f = new File([contents], relativePath.split('/').pop()!);
+  Object.defineProperty(f, 'webkitRelativePath', { value: relativePath });
+  return f;
+};
+
+const asFileList = (files: File[]): FileList =>
+  Object.assign(files, { item: (i: number) => files[i] }) as unknown as FileList;
+
+const zipBytes = (entries: Record<string, string>): Promise<Uint8Array> =>
+  new Promise((resolve, reject) => {
+    const encoded: Record<string, Uint8Array> = {};
+    for (const [path, contents] of Object.entries(entries))
+      encoded[path] = encoder.encode(contents);
+    zip(encoded, (err, out) => (err ? reject(err) : resolve(out)));
+  });
+
+describe('readFileList', () => {
+  it('reads a folder selection into root-relative ProcessedFiles', async () => {
+    const files = await readFileList(
+      asFileList([pickedFile('site/index.html', '<h1>hi</h1>'), pickedFile('site/css/site.css')])
+    );
+    // The common root folder is stripped so config sits at the deploy root.
+    expect(files.map(f => f.path).sort()).toEqual(['/css/site.css', '/index.html']);
+    expect(files[0].sha).toMatch(/^[0-9a-f]{40}$/);
+  });
+
+  it('does not strip a shared folder when a file sits beside it at the root', async () => {
+    const files = await readFileList(
+      asFileList([pickedFile('index.html'), pickedFile('assets/app.js')])
+    );
+    expect(files.map(f => f.path).sort()).toEqual(['/assets/app.js', '/index.html']);
+  });
+
+  it('rejects a single loose file that is neither a zip nor an HTML page', async () => {
+    await expect(readFileList(asFileList([pickedFile('photo.png')]))).rejects.toBeInstanceOf(
+      UnsupportedDropError
+    );
+  });
+
+  it('allows a lone HTML page to stand alone', async () => {
+    const files = await readFileList(asFileList([pickedFile('page.html', '<p>solo</p>')]));
+    expect(files).toHaveLength(1);
+    expect(files[0].path).toBe('/page.html');
+  });
+
+  it('expands a single dropped zip, skipping directories and junk entries', async () => {
+    const bytes = await zipBytes({
+      'my-site/index.html': '<h1>zipped</h1>',
+      'my-site/__MACOSX/._index.html': 'resource fork',
+      'my-site/.DS_Store': 'junk',
+      'my-site/node_modules/pkg/index.js': 'dep',
+      'my-site/css/site.css': 'body{}',
+    });
+    const files = await readFileList(
+      asFileList([new File([bytes.buffer.slice(0) as ArrayBuffer], 'my-site.zip')])
+    );
+    expect(files.map(f => f.path).sort()).toEqual(['/css/site.css', '/index.html']);
+  });
+});
+
+describe('index.html helpers', () => {
+  it('names the lone non-index HTML file, and only that case', () => {
+    expect(getSingleNonIndexHtmlFileName([processed('/about.html'), processed('/a.css')])).toBe(
+      'about.html'
+    );
+    expect(
+      getSingleNonIndexHtmlFileName([processed('/index.html'), processed('/about.html')])
+    ).toBeNull();
+    expect(getSingleNonIndexHtmlFileName([processed('/a.html'), processed('/b.html')])).toBeNull();
+    expect(getSingleNonIndexHtmlFileName([processed('/a.css')])).toBeNull();
+  });
+
+  it('flags multiple HTML files with no index', () => {
+    expect(hasMultipleHtmlFilesWithoutIndex([processed('/a.html'), processed('/b.html')])).toBe(
+      true
+    );
+    expect(hasMultipleHtmlFilesWithoutIndex([processed('/index.html'), processed('/b.html')])).toBe(
+      false
+    );
+    expect(hasMultipleHtmlFilesWithoutIndex([processed('/a.html')])).toBe(false);
+  });
+
+  it('renames the lone HTML page to index.html in place, keeping its directory', () => {
+    const input = [processed('/docs/about.html'), processed('/docs/site.css')];
+    const renamed = renameSingleNonIndexHtmlToIndex(input);
+    const page = renamed.find(f => f.name === 'index.html')!;
+    expect(page.path).toBe('/docs/index.html');
+    // Content and sha untouched — only the served path changes.
+    expect(page.sha).toBe(input[0].sha);
+    expect(page.content).toBe(input[0].content);
+  });
+
+  it('leaves sets with an index, several pages, or no HTML unchanged', () => {
+    const withIndex = [processed('/index.html'), processed('/about.html')];
+    expect(renameSingleNonIndexHtmlToIndex(withIndex)).toBe(withIndex);
+  });
+});

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

@@ -40,15 +40,21 @@ export interface DeployResult {
  * zipping → creating → uploading → building → ready.
  */
 export type DeployPhase =
-  | 'zipping'
-  | 'creating'
-  | 'uploading'
-  | 'processing'
-  | 'building'
-  | 'ready';
+  'zipping' | 'creating' | 'uploading' | 'processing' | 'building' | 'ready';
 
 export interface DeployProgress {
   phase: DeployPhase;
   uploaded?: number;
   total?: number;
 }
+
+/** The subset of a Netlify Site the drop flow needs to redirect and report. */
+export interface BuildSite {
+  /** site id (UUID) */
+  id: string;
+  /** the *.netlify.app subdomain, also the app's URL segment */
+  name: string;
+  /** https://<name>.netlify.app */
+  ssl_url?: string;
+  url?: string;
+}

package/packages/drop-core/zip.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest';
+import { unzip } from 'fflate';
+import { generateNetlifyToml, zipFiles } from './zip';
+import type { ProcessedFile } from './types';
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+const file = (path: string, contents = 'x'): ProcessedFile => {
+  const content = encoder.encode(contents).buffer as ArrayBuffer;
+  return { path, content, size: content.byteLength, sha: 'test-sha', name: path.split('/').pop()! };
+};
+
+const buildableProject = () => [
+  file('/index.html', '<h1>hi</h1>'),
+  file(
+    '/package.json',
+    JSON.stringify({ scripts: { build: 'astro build' }, dependencies: { astro: '^4' } })
+  ),
+];
+
+const unzipArchive = async (archive: File): Promise<Record<string, string>> => {
+  const bytes = new Uint8Array(await archive.arrayBuffer());
+  const entries = await new Promise<Record<string, Uint8Array>>((resolve, reject) =>
+    unzip(bytes, (err, data) => (err ? reject(err) : resolve(data)))
+  );
+  return Object.fromEntries(Object.entries(entries).map(([k, v]) => [k, decoder.decode(v)]));
+};
+
+describe('generateNetlifyToml', () => {
+  it('renders only command and publish — everything else stays zero-config', () => {
+    expect(
+      generateNetlifyToml({ command: 'npm run build', publish: 'dist', framework: 'astro' })
+    ).toBe('[build]\n  command = "npm run build"\n  publish = "dist"\n');
+  });
+
+  it('escapes TOML basic-string metacharacters', () => {
+    const toml = generateNetlifyToml({ command: 'echo "a\\b"', publish: 'dist', framework: 'x' });
+    expect(toml).toContain('command = "echo \\"a\\\\b\\""');
+  });
+});
+
+describe('zipFiles', () => {
+  it('throws on an empty file set', async () => {
+    await expect(zipFiles([])).rejects.toThrow('No files to deploy');
+  });
+
+  it('zips files with archive-root-relative paths (no leading slash)', async () => {
+    const { file: archive, buildSettings } = await zipFiles([file('/index.html', '<h1>hi</h1>')]);
+    expect(archive.name).toBe('source.zip');
+    expect(archive.type).toBe('application/zip');
+    expect(buildSettings).toBeNull(); // nothing inferable for a static site
+    expect(await unzipArchive(archive)).toEqual({ 'index.html': '<h1>hi</h1>' });
+  });
+
+  it('synthesises a netlify.toml when settings are inferable', async () => {
+    const { file: archive, buildSettings } = await zipFiles(buildableProject());
+    expect(buildSettings).toEqual({
+      command: 'npm run build',
+      publish: 'dist',
+      framework: 'astro',
+    });
+    const entries = await unzipArchive(archive);
+    expect(entries['netlify.toml']).toContain('[build]');
+    expect(entries['netlify.toml']).toContain('publish = "dist"');
+  });
+
+  it('appends to an existing netlify.toml so redirects and headers survive', async () => {
+    const existing = '[[redirects]]\n  from = "/old"\n  to = "/new"\n';
+    const { file: archive } = await zipFiles([
+      ...buildableProject(),
+      file('/netlify.toml', existing),
+    ]);
+    const toml = (await unzipArchive(archive))['netlify.toml'];
+    expect(toml).toContain('[[redirects]]');
+    expect(toml).toContain('[build]');
+    expect(toml.indexOf('[[redirects]]')).toBeLessThan(toml.indexOf('[build]'));
+  });
+
+  it('uploads the drop untouched when synthesizeNetlifyToml is off', async () => {
+    const { file: archive, buildSettings } = await zipFiles(buildableProject(), {
+      synthesizeNetlifyToml: false,
+    });
+    expect(buildSettings).toBeNull();
+    expect((await unzipArchive(archive))['netlify.toml']).toBeUndefined();
+  });
+
+  it('honors a custom archive name', async () => {
+    const { file: archive } = await zipFiles([file('/index.html')], { name: 'drop.zip' });
+    expect(archive.name).toBe('drop.zip');
+  });
+});

package/dist/components/preact/DropZone/drop-core/authedDropClient.js

@@ -1,123 +0,0 @@
-var h = Object.defineProperty;
-var p = (r, e, o) => e in r ? h(r, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : r[e] = o;
-var i = (r, e, o) => p(r, typeof e != "symbol" ? e + "" : e, o);
-import { apiError as d } from "./client.js";
-import { NotAuthenticatedError as l, SiteCreateError as u } from "./errors.js";
-const y = "/access-control/bb-api/api/v1", w = "https://api.netlify.com/api/v1", T = 1e3, f = 10 * 60 * 1e3, k = 20 * 1e3, m = /* @__PURE__ */ new Set(["ready", "error", "rejected"]);
-class g {
-  constructor({
-    proxyBase: e = y,
-    apiBase: o = w,
-    getUploadToken: n,
-    accountSlug: s,
-    pollIntervalMs: a = T,
-    timeoutMs: t = f
-  }) {
-    i(this, "proxyBase");
-    i(this, "apiBase");
-    i(this, "getUploadToken");
-    i(this, "accountSlug");
-    i(this, "pollIntervalMs");
-    i(this, "timeoutMs");
-    i(this, "cachedToken");
-    this.proxyBase = e, this.apiBase = o, this.getUploadToken = n, this.accountSlug = s, this.pollIntervalMs = a, this.timeoutMs = t;
-  }
-  /**
-   * The auth gate. Minting here — before anything is created — is what lets a
-   * logged-out visitor fail cleanly and fall back to the anonymous flow. The
-   * returned token is threaded through `deployFiles`, but only the uploads
-   * actually need one, and they re-mint rather than trusting this to still be
-   * valid by the time they run.
-   */
-  async getToken() {
-    const e = await this.getUploadToken();
-    if (!e) throw new l();
-    return this.cachedToken = { value: e, mintedAt: Date.now() }, e;
-  }
-  /**
-   * A token young enough to authorize an upload, minting a new one once the
-   * cached one nears its 30s expiry.
-   *
-   * Deliberately NOT `NotAuthenticatedError` when minting fails: by the time
-   * uploads run the site already exists, and that error would send the drop
-   * back through the anonymous path — leaving an empty project behind and
-   * deploying a duplicate. See the class doc.
-   */
-  async freshToken() {
-    const e = Date.now();
-    if (this.cachedToken && e - this.cachedToken.mintedAt < k)
-      return this.cachedToken.value;
-    const o = await this.getUploadToken();
-    if (!o) throw new Error("could not renew the upload token");
-    return this.cachedToken = { value: o, mintedAt: e }, o;
-  }
-  /**
-   * Two proxied calls: create the site in the visitor's account, then the
-   * deploy on it. Mapped into the anonymous `DropResponse` shape so
-   * `deployFiles` runs unchanged over either client.
-   */
-  async createDeploy(e, o) {
-    const n = this.accountSlug ? `/${this.accountSlug}/sites` : "/sites", s = await fetch(`${this.proxyBase}${n}`, {
-      method: "POST",
-      credentials: "include",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ created_via: "drop" })
-    });
-    if (s.status === 401 || s.status === 403) throw new l();
-    if (!s.ok) throw new u(s.status);
-    const a = await s.json(), t = await fetch(`${this.proxyBase}/sites/${a.id}/deploys`, {
-      method: "POST",
-      credentials: "include",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ files: e, deploy_source: "drop" })
-    });
-    if (!t.ok) throw d("deploy create", t.status);
-    const c = await t.json();
-    return {
-      id: a.id,
-      deploy_id: c.id,
-      subdomain: a.name,
-      required: c.required ?? []
-    };
-  }
-  /**
-   * Direct to `api.netlify.com` on a freshly-aged bearer — the threaded `token`
-   * is ignored because an upload queue easily outlives the 30 seconds it was
-   * minted with. PUT (not POST) so paths with "&" etc. work.
-   */
-  async uploadFile(e, o, n, s) {
-    const a = await this.freshToken(), t = await fetch(`${this.apiBase}/deploys/${e}/files${o}`, {
-      method: "PUT",
-      headers: { "Content-Type": "application/octet-stream", Authorization: `Bearer ${a}` },
-      body: n
-    });
-    if (!t.ok) throw d(`upload ${o}`, t.status);
-  }
-  /**
-   * Poll the deploy through the proxy until it settles: resolve on `ready`,
-   * throw on `error`/`rejected`, throw on timeout. On the session cookie rather
-   * than a bearer, so a deploy taking minutes can't outlive its own credentials.
-   */
-  async waitUntilReady(e, o) {
-    const n = this.timeoutMs / this.pollIntervalMs;
-    for (let s = 0; s < n; s++) {
-      const a = await fetch(`${this.proxyBase}/deploys/${e.deploy_id}`, {
-        credentials: "include"
-      });
-      if (a.ok) {
-        const t = await a.json();
-        if (t.state && m.has(t.state)) {
-          if (t.state === "ready") return;
-          throw new Error(
-            t.error_message ? `deploy failed: ${t.error_message}` : "deploy failed"
-          );
-        }
-      }
-      await new Promise((t) => setTimeout(t, this.pollIntervalMs));
-    }
-    throw new Error("Deploy did not become ready in time");
-  }
-}
-export {
-  g as AuthenticatedDropClient
-};