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

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

@@ -160,6 +160,8 @@ function ne({
           return /* @__PURE__ */ e(o, { label: "Site’s live — taking you to claim it…" });
         case "dashboard":
           return /* @__PURE__ */ e(o, { label: "Site’s live — taking you to your new project…" });
+        default:
+          return null;
       }
     case "uploading": {
       const c = r.total ? Math.round(r.uploaded / r.total * 100) : 0;

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

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

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

@@ -1,4 +1,6 @@
 import { BuildSite } from './types';
+import { SettledDeploy } from './pollDeploy';
+export type { SettledDeploy } from './pollDeploy';
 /**
  * Transport shared by both authenticated clients: JSON rides the consumer's
  * access-control rewrite on the session cookie. Uploads are each client's own
@@ -10,19 +12,9 @@ import { BuildSite } from './types';
  * 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. */
-export type SettledDeploy = {
-    outcome: 'ready';
-} | {
-    outcome: 'failed';
-    errorMessage?: string;
-} | {
-    outcome: 'timed-out';
-};
 /**
- * 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.
+ * Polls a deploy over the session-cookie proxy — the shared `pollUntilSettled`
+ * loop with the cookie transport bound in. A non-ok read is skipped, not fatal.
  */
 export declare function pollDeployUntilSettled(options: {
     proxyBase: string;

package/dist/drop-core/authedApi.js

@@ -1,30 +1,29 @@
-import { NotAuthenticatedError as d, SiteCreateError as l } from "./errors.js";
-async function f(r, o) {
-  const s = o ? `/${o}/sites` : "/sites", e = await fetch(`${r}${s}`, {
+import { NotAuthenticatedError as a, SiteCreateError as l } from "./errors.js";
+import { pollUntilSettled as c } from "./pollDeploy.js";
+async function u(o, e) {
+  const n = e ? `/${e}/sites` : "/sites", t = await fetch(`${o}${n}`, {
     method: "POST",
     credentials: "include",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ created_via: "drop" })
   });
-  if (e.status === 401 || e.status === 403) throw new d();
-  if (!e.ok) throw new l(e.status);
-  return e.json();
+  if (t.status === 401 || t.status === 403) throw new a();
+  if (!t.ok) throw new l(t.status);
+  return t.json();
 }
-const u = /* @__PURE__ */ new Set(["ready", "error", "rejected"]);
-async function y(r) {
-  const { proxyBase: o, deployId: s, pollIntervalMs: e, timeoutMs: i } = r, c = i / e;
-  for (let n = 0; n < c; n++) {
-    const a = await fetch(`${o}/deploys/${s}`, { credentials: "include" });
-    if (a.ok) {
-      const t = await a.json();
-      if (t.state && u.has(t.state))
-        return t.state === "ready" ? { outcome: "ready" } : { outcome: "failed", errorMessage: t.error_message };
+function f(o) {
+  const { proxyBase: e, deployId: n, pollIntervalMs: t, timeoutMs: s } = o;
+  return c({
+    deployId: n,
+    pollIntervalMs: t,
+    timeoutMs: s,
+    readState: async (i) => {
+      const r = await fetch(`${e}/deploys/${i}`, { credentials: "include" });
+      return r.ok ? r.json() : null;
     }
-    await new Promise((t) => setTimeout(t, e));
-  }
-  return { outcome: "timed-out" };
+  });
 }
 export {
-  f as createSiteInAccount,
-  y as pollDeployUntilSettled
+  u as createSiteInAccount,
+  f as pollDeployUntilSettled
 };

package/dist/drop-core/client.js

@@ -1,15 +1,16 @@
-import { DEFAULT_API_BASE as p, DEFAULT_POLL_INTERVAL_MS as l, DEFAULT_TIMEOUT_MS as h } from "./constants.js";
-import { DeployTimeoutError as d } from "./errors.js";
-function i(r, t) {
-  return Object.assign(new Error(`${r} failed: ${t}`), { status: t });
+import { DEFAULT_API_BASE as n, DEFAULT_POLL_INTERVAL_MS as l, DEFAULT_TIMEOUT_MS as p } from "./constants.js";
+import { DeployFailedError as d, DeployTimeoutError as c } from "./errors.js";
+import { pollUntilSettled as h } from "./pollDeploy.js";
+function a(i, t) {
+  return Object.assign(new Error(`${i} failed: ${t}`), { status: t });
 }
-class y {
-  constructor(t = p, o = l, e = h) {
+class m {
+  constructor(t = n, o = l, e = p) {
     this.apiBase = t, this.pollIntervalMs = o, this.timeoutMs = e;
   }
   async getToken() {
     const t = await fetch(`${this.apiBase}/drop/token`, { method: "POST" });
-    if (!t.ok) throw i("drop/token", t.status);
+    if (!t.ok) throw a("drop/token", t.status);
     return (await t.json()).token;
   }
   async createDeploy(t, o) {
@@ -18,30 +19,37 @@ class y {
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ files: t, token: o })
     });
-    if (!e.ok) throw i("drop", e.status);
+    if (!e.ok) throw a("drop", e.status);
     return e.json();
   }
-  async uploadFile(t, o, e, a) {
-    const s = await fetch(`${this.apiBase}/deploys/${t}/files${o}`, {
+  async uploadFile(t, o, e, s) {
+    const r = await fetch(`${this.apiBase}/deploys/${t}/files${o}`, {
       method: "PUT",
-      headers: { "Content-Type": "application/octet-stream", Authorization: `Bearer ${a}` },
+      headers: { "Content-Type": "application/octet-stream", Authorization: `Bearer ${s}` },
       body: e
     });
-    if (!s.ok) throw i(`upload ${o}`, s.status);
+    if (!r.ok) throw a(`upload ${o}`, r.status);
   }
   async waitUntilReady(t, o) {
-    const e = this.timeoutMs / this.pollIntervalMs;
-    for (let a = 0; a < e; a++) {
-      const s = await fetch(`${this.apiBase}/deploys/${t.deploy_id}`, {
-        headers: { Authorization: `Bearer ${o}` }
-      });
-      if (s.ok && (await s.json()).state === "ready") return;
-      await new Promise((n) => setTimeout(n, this.pollIntervalMs));
-    }
-    throw new d();
+    const e = await h({
+      deployId: t.deploy_id,
+      pollIntervalMs: this.pollIntervalMs,
+      timeoutMs: this.timeoutMs,
+      // `/deploys/{id}` expects the deploy_id (BSON), not the site id (UUID) that
+      // lives at `deploy.id`. See drop_controller.rb; Deploy.find(uuid) is nil and
+      // the request 401s misleadingly via require_current_actor!.
+      readState: async (s) => {
+        const r = await fetch(`${this.apiBase}/deploys/${s}`, {
+          headers: { Authorization: `Bearer ${o}` }
+        });
+        return r.ok ? r.json() : null;
+      }
+    });
+    if (e.outcome !== "ready")
+      throw e.outcome === "failed" ? new d(e.errorMessage) : new c();
   }
 }
 export {
-  y as AnonymousDropClient,
-  i as apiError
+  m as AnonymousDropClient,
+  a as apiError
 };

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

@@ -0,0 +1,31 @@
+/**
+ * The single deploy poller both drop clients share. The loop and its
+ * terminal-state policy live here once; transport (cookie proxy vs bearer) is
+ * injected via `readState`, so the anonymous and authenticated paths can't
+ * drift on what "done" means.
+ */
+/** 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';
+};
+/** The slice of a deploy record the poller reads; `null` = a read that failed and should be skipped. */
+export interface DeployState {
+    state?: string;
+    error_message?: string;
+}
+/**
+ * Poll until the deploy reaches a terminal state or the timeout elapses.
+ * A `null` read is skipped, not fatal — a transient hiccup shouldn't kill a
+ * progressing deploy. Callers map the outcome onto their own error vocabulary.
+ */
+export declare function pollUntilSettled(options: {
+    deployId: string;
+    pollIntervalMs: number;
+    timeoutMs: number;
+    readState: (deployId: string) => Promise<DeployState | null>;
+}): Promise<SettledDeploy>;

package/dist/drop-core/pollDeploy.js

@@ -0,0 +1,14 @@
+const c = /* @__PURE__ */ new Set(["ready", "error", "rejected"]);
+async function l(r) {
+  const { deployId: a, pollIntervalMs: t, timeoutMs: s, readState: n } = r, i = s / t;
+  for (let o = 0; o < i; o++) {
+    const e = await n(a);
+    if (e != null && e.state && c.has(e.state))
+      return e.state === "ready" ? { outcome: "ready" } : { outcome: "failed", errorMessage: e.error_message };
+    await new Promise((d) => setTimeout(d, t));
+  }
+  return { outcome: "timed-out" };
+}
+export {
+  l as pollUntilSettled
+};

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

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@netlify/spark-ui",
   "description": "Assets, design tokens, components, and utilities",
-  "version": "1.31.0-alpha.7",
+  "version": "1.31.0",
   "type": "module",
   "main": "dist/components/preact/index.js",
   "types": "dist/components/preact/index.d.ts",
@@ -65,7 +65,6 @@
     "fake-indexeddb": "^6.2.5",
     "glob": "^11.0.1",
     "happy-dom": "^20.11.6",
-    "jsdom": "^30.0.0",
     "preact": "^10.26.4",
     "prettier": "^3.5.3",
     "prettier-plugin-astro": "^0.14.1",

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

@@ -309,6 +309,8 @@ function StatusView({
           return <Spinner label="Site’s live — taking you to claim it…" />;
         case 'dashboard':
           return <Spinner label="Site’s live — taking you to your new project…" />;
+        default:
+          return null;
       }
 
     case 'uploading': {

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

@@ -346,6 +346,9 @@ describe('stash resume on mount', () => {
     expect(clearDropStash).not.toHaveBeenCalled(); // preserved for the next authenticated visit
     expect(harness.api.status.kind).toBe('idle');
     expect(harness.errors).toHaveLength(0);
+    // Nothing deployed, so no resume was counted — otherwise every logged-out
+    // reload with a stash would inflate the metric.
+    expect(harness.events.map(e => e.event)).not.toContain(DROPZONE_EVENTS.RESUMED);
   });
 
   it('surfaces a real resume failure with re-drop copy, stash consumed', async () => {

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

@@ -268,11 +268,15 @@ export function useDropDeploy({
       onError?.({ message, reason });
     };
 
+    // Set once the file set is read, so a later throw still reports file_count.
+    let knownFileCount: number | undefined;
+
     try {
       // Rename a lone non-index HTML file so it is served at the site root.
       // Warnings are computed on the renamed set, so the fixable single-file
       // case no longer warns and only the multi-HTML case does.
       const files = renameSingleNonIndexHtmlToIndex(await read());
+      knownFileCount = files.length;
       if (!files.length) {
         fail('No files found to deploy.', 'No files found to deploy.', { file_count: 0 });
         return;
@@ -297,7 +301,11 @@ export function useDropDeploy({
       }
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
-      fail(humanizeDropError(err), reason);
+      fail(
+        humanizeDropError(err),
+        reason,
+        knownFileCount !== undefined ? { file_count: knownFileCount } : undefined
+      );
     }
   }
 
@@ -481,7 +489,6 @@ export function useDropDeploy({
       return;
     }
 
-    emit(DROPZONE_EVENTS.RESUMED, {});
     setStatus({ kind: 'creating' });
 
     const archive: ZipResult = { file: stash.zipFile, buildSettings: stash.buildSettings };
@@ -496,11 +503,13 @@ export function useDropDeploy({
 
     if (!built) {
       // Still no session — the visitor came back logged out. Keep the stash for
-      // their next authenticated visit.
+      // their next authenticated visit. No RESUMED event: nothing deployed.
       setStatus({ kind: 'idle' });
       return;
     }
 
+    // Only now is a resume real — a logged-out attempt above never counts.
+    emit(DROPZONE_EVENTS.RESUMED, {});
     await clearDropStash();
     setStatus({ kind: 'redirecting', target: 'build' });
     onBuildDeploy?.(built);

package/packages/drop-core/authedApi.ts

@@ -1,5 +1,8 @@
 import type { BuildSite } from './types';
 import { NotAuthenticatedError, SiteCreateError } from './errors';
+import { pollUntilSettled, type SettledDeploy } from './pollDeploy';
+
+export type { SettledDeploy } from './pollDeploy';
 
 /**
  * Transport shared by both authenticated clients: JSON rides the consumer's
@@ -28,41 +31,24 @@ export async function createSiteInAccount(
   return res.json();
 }
 
-/** 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' };
-
-/** Deploy states that end the wait — `ready` succeeds, the rest are failures. */
-const TERMINAL_STATES = new Set(['ready', 'error', 'rejected']);
-
-interface DeployState {
-  state?: string;
-  error_message?: string;
-}
-
 /**
- * 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.
+ * Polls a deploy over the session-cookie proxy — the shared `pollUntilSettled`
+ * loop with the cookie transport bound in. A non-ok read is skipped, not fatal.
  */
-export async function pollDeployUntilSettled(options: {
+export function pollDeployUntilSettled(options: {
   proxyBase: string;
   deployId: string;
   pollIntervalMs: number;
   timeoutMs: number;
 }): Promise<SettledDeploy> {
   const { proxyBase, deployId, pollIntervalMs, timeoutMs } = options;
-  const deadline = timeoutMs / pollIntervalMs;
-  for (let i = 0; i < deadline; i++) {
-    const res = await fetch(`${proxyBase}/deploys/${deployId}`, { credentials: 'include' });
-    if (res.ok) {
-      const deploy: DeployState = await res.json();
-      if (deploy.state && TERMINAL_STATES.has(deploy.state)) {
-        if (deploy.state === 'ready') return { outcome: 'ready' };
-        return { outcome: 'failed', errorMessage: deploy.error_message };
-      }
-    }
-    await new Promise(r => setTimeout(r, pollIntervalMs));
-  }
-  return { outcome: 'timed-out' };
+  return pollUntilSettled({
+    deployId,
+    pollIntervalMs,
+    timeoutMs,
+    readState: async id => {
+      const res = await fetch(`${proxyBase}/deploys/${id}`, { credentials: 'include' });
+      return res.ok ? res.json() : null;
+    },
+  });
 }

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

@@ -0,0 +1,29 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { AnonymousDropClient } from './client';
+import { DeployFailedError } from './errors';
+import type { DropResponse } from './types';
+
+const deploy: DropResponse = { id: 'site', deploy_id: 'd', subdomain: 'x', required: [] };
+const client = () => new AnonymousDropClient('https://api', 1, 50);
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe('AnonymousDropClient.waitUntilReady', () => {
+  it('resolves once the deploy is ready', async () => {
+    vi.stubGlobal('fetch', async () => ({ ok: true, json: async () => ({ state: 'ready' }) }));
+    await expect(client().waitUntilReady(deploy, 'tok')).resolves.toBeUndefined();
+  });
+
+  // Regression: a failed anonymous deploy used to poll to the full timeout.
+  it('fails fast on a failed deploy instead of timing out', async () => {
+    vi.stubGlobal('fetch', async () => ({
+      ok: true,
+      json: async () => ({ state: 'error', error_message: 'nope' }),
+    }));
+    const err = await client()
+      .waitUntilReady(deploy, 'tok')
+      .catch(e => e);
+    expect(err).toBeInstanceOf(DeployFailedError);
+    expect(err.reason).toBe('nope');
+  });
+});

package/packages/drop-core/client.ts

@@ -3,7 +3,8 @@
  * interface, so `deployFiles` runs the same pipeline anonymous or authenticated.
  */
 import { DEFAULT_API_BASE, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS } from './constants';
-import { DeployTimeoutError } from './errors';
+import { DeployFailedError, DeployTimeoutError } from './errors';
+import { pollUntilSettled } from './pollDeploy';
 import type { DropResponse, Digest } from './types';
 
 /** A normal Error with the response's HTTP status attached, so callers can branch on it directly. */
@@ -61,17 +62,24 @@ export class AnonymousDropClient implements DropClient {
   }
 
   async waitUntilReady(deploy: DropResponse, token: string): Promise<void> {
-    // `/deploys/{id}` expects the deploy_id (BSON), not the site id (UUID) that
-    // lives at `deploy.id`. See drop_controller.rb; Deploy.find(uuid) is nil and
-    // the request 401s misleadingly via require_current_actor!.
-    const deadline = this.timeoutMs / this.pollIntervalMs;
-    for (let i = 0; i < deadline; i++) {
-      const res = await fetch(`${this.apiBase}/deploys/${deploy.deploy_id}`, {
-        headers: { Authorization: `Bearer ${token}` },
-      });
-      if (res.ok && (await res.json()).state === 'ready') return;
-      await new Promise(r => setTimeout(r, this.pollIntervalMs));
-    }
+    const settled = await pollUntilSettled({
+      deployId: deploy.deploy_id,
+      pollIntervalMs: this.pollIntervalMs,
+      timeoutMs: this.timeoutMs,
+      // `/deploys/{id}` expects the deploy_id (BSON), not the site id (UUID) that
+      // lives at `deploy.id`. See drop_controller.rb; Deploy.find(uuid) is nil and
+      // the request 401s misleadingly via require_current_actor!.
+      readState: async id => {
+        const res = await fetch(`${this.apiBase}/deploys/${id}`, {
+          headers: { Authorization: `Bearer ${token}` },
+        });
+        return res.ok ? res.json() : null;
+      },
+    });
+    if (settled.outcome === 'ready') return;
+    // A failed deploy now surfaces immediately instead of waiting out the full
+    // timeout, matching the authenticated path.
+    if (settled.outcome === 'failed') throw new DeployFailedError(settled.errorMessage);
     throw new DeployTimeoutError();
   }
 }

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

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { pollUntilSettled } from './pollDeploy';
+
+const base = { deployId: 'd', pollIntervalMs: 1, timeoutMs: 50 };
+
+describe('pollUntilSettled', () => {
+  it('resolves ready when the deploy reaches ready', async () => {
+    const settled = await pollUntilSettled({ ...base, readState: async () => ({ state: 'ready' }) });
+    expect(settled).toEqual({ outcome: 'ready' });
+  });
+
+  it('reports failure with the API message on error/rejected', async () => {
+    for (const state of ['error', 'rejected']) {
+      const settled = await pollUntilSettled({
+        ...base,
+        readState: async () => ({ state, error_message: 'boom' }),
+      });
+      expect(settled).toEqual({ outcome: 'failed', errorMessage: 'boom' });
+    }
+  });
+
+  it('times out when the deploy never settles (does not hang on failure states either)', async () => {
+    const settled = await pollUntilSettled({
+      ...base,
+      timeoutMs: 3,
+      readState: async () => ({ state: 'building' }),
+    });
+    expect(settled).toEqual({ outcome: 'timed-out' });
+  });
+
+  it('skips a null read without settling, then resolves', async () => {
+    let calls = 0;
+    const settled = await pollUntilSettled({
+      ...base,
+      readState: async () => (++calls < 3 ? null : { state: 'ready' }),
+    });
+    expect(settled).toEqual({ outcome: 'ready' });
+    expect(calls).toBeGreaterThanOrEqual(3);
+  });
+
+  it('waits through non-terminal states then settles on the terminal one', async () => {
+    const states = ['uploading', 'processing', 'ready'];
+    let i = 0;
+    const settled = await pollUntilSettled({
+      ...base,
+      readState: async () => ({ state: states[Math.min(i++, states.length - 1)] }),
+    });
+    expect(settled).toEqual({ outcome: 'ready' });
+  });
+});

package/packages/drop-core/pollDeploy.ts

@@ -0,0 +1,46 @@
+/**
+ * The single deploy poller both drop clients share. The loop and its
+ * terminal-state policy live here once; transport (cookie proxy vs bearer) is
+ * injected via `readState`, so the anonymous and authenticated paths can't
+ * drift on what "done" means.
+ */
+
+/** 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' };
+
+/** The slice of a deploy record the poller reads; `null` = a read that failed and should be skipped. */
+export interface DeployState {
+  state?: string;
+  error_message?: string;
+}
+
+/** `ready` succeeds; `error`/`rejected` are failures; anything else keeps waiting. */
+const TERMINAL_STATES = new Set(['ready', 'error', 'rejected']);
+
+/**
+ * Poll until the deploy reaches a terminal state or the timeout elapses.
+ * A `null` read is skipped, not fatal — a transient hiccup shouldn't kill a
+ * progressing deploy. Callers map the outcome onto their own error vocabulary.
+ */
+export async function pollUntilSettled(options: {
+  deployId: string;
+  pollIntervalMs: number;
+  timeoutMs: number;
+  readState: (deployId: string) => Promise<DeployState | null>;
+}): Promise<SettledDeploy> {
+  const { deployId, pollIntervalMs, timeoutMs, readState } = options;
+  const deadline = timeoutMs / pollIntervalMs;
+  for (let i = 0; i < deadline; i++) {
+    const deploy = await readState(deployId);
+    if (deploy?.state && TERMINAL_STATES.has(deploy.state)) {
+      return deploy.state === 'ready'
+        ? { outcome: 'ready' }
+        : { outcome: 'failed', errorMessage: deploy.error_message };
+    }
+    await new Promise(r => setTimeout(r, pollIntervalMs));
+  }
+  return { outcome: 'timed-out' };
+}

package/dist/components/articleCopyActions.d.ts

@@ -1,9 +0,0 @@
-/**
- * Wire up the "Copy URL" / "Copy page" buttons rendered by ArticleCopyActions.astro.
- *
- * This runs on every `astro:page-load` (initial load *and* every client-side
- * navigation via `<ClientRouter />`), so the buttons keep working after routing
- * to another article/post. Each wrapper is guarded so re-initialising the same
- * DOM node never attaches duplicate listeners.
- */
-export declare function initArticleCopyActions(root?: ParentNode): void;

package/packages/components/ArticleCopyActions.astro

@@ -1,122 +0,0 @@
----
-interface Props {
-  url: string;
-  content: string;
-  title?: string;
-  class?: string;
-  copyUrlLabel?: string;
-  copyContentLabel?: string;
-  copiedLabel?: string;
-  trackingProps?: Record<string, string>;
-  trackingSelectorClass?: string;
-}
-
-const {
-  url,
-  content,
-  title,
-  class: className,
-  copyUrlLabel = 'Copy URL',
-  copyContentLabel = 'Copy page',
-  copiedLabel = 'Copied!',
-  trackingProps = {},
-  trackingSelectorClass,
-} = Astro.props;
-
-const copyContent = title ? `# ${title}\n\n${content}` : content;
----
-
-<div class:list={['copy-actions', className]} data-copied-label={copiedLabel}>
-  <button
-    type="button"
-    class:list={['copy-actions-action', 'copy-actions-copy-url', trackingSelectorClass]}
-    data-copy="url"
-    data-value={url}
-    data-track-action="copy_url"
-    {...trackingProps}
-  >
-    <svg
-      class="copy-actions-icon"
-      viewBox="0 0 16 16"
-      fill="none"
-      stroke="currentColor"
-      stroke-width="1.3"
-      stroke-linecap="round"
-      stroke-linejoin="round"
-      aria-hidden="true"
-      role="presentation"
-    >
-      <path d="M6.5 9.5a2.5 2.5 0 0 0 3.6.1l2-2a2.5 2.5 0 0 0-3.6-3.6l-1.1 1.1"></path>
-      <path d="M9.5 6.5a2.5 2.5 0 0 0-3.6-.1l-2 2a2.5 2.5 0 0 0 3.6 3.6l1.1-1.1"></path>
-    </svg>
-    <span class="copy-actions-label">{copyUrlLabel}</span>
-  </button>
-  <button
-    type="button"
-    class:list={['copy-actions-action', 'copy-actions-copy-content', trackingSelectorClass]}
-    data-copy="page"
-    data-track-action="copy_page"
-    {...trackingProps}
-  >
-    <svg
-      class="copy-actions-icon"
-      viewBox="0 0 16 16"
-      fill="currentColor"
-      aria-hidden="true"
-      role="presentation"
-    >
-      <path
-        d="M4.83333 1C3.82214 1 3 1.78477 3 2.75V13.25C3 14.2152 3.82214 15 4.83333 15H12.1667C13.1779 15 14 14.2152 14 13.25V5.375H10.3333C9.8263 5.375 9.41667 4.98398 9.41667 4.5V1H4.83333ZM10.3333 1V4.5H14L10.3333 1ZM6.20833 8H10.7917C11.0438 8 11.25 8.19687 11.25 8.4375C11.25 8.67813 11.0438 8.875 10.7917 8.875H6.20833C5.95625 8.875 5.75 8.67813 5.75 8.4375C5.75 8.19687 5.95625 8 6.20833 8ZM6.20833 9.75H10.7917C11.0438 9.75 11.25 9.94687 11.25 10.1875C11.25 10.4281 11.0438 10.625 10.7917 10.625H6.20833C5.95625 10.625 5.75 10.4281 5.75 10.1875C5.75 9.94687 5.95625 9.75 6.20833 9.75ZM6.20833 11.5H10.7917C11.0438 11.5 11.25 11.6969 11.25 11.9375C11.25 12.1781 11.0438 12.375 10.7917 12.375H6.20833C5.95625 12.375 5.75 12.1781 5.75 11.9375C5.75 11.6969 5.95625 11.5 6.20833 11.5Z"
-      ></path>
-    </svg>
-    <span class="copy-actions-label">{copyContentLabel}</span>
-  </button>
-</div>
-
-<script is:inline type="text/plain" data-copy-actions-source set:text={copyContent} />
-
-<style>
-  .copy-actions {
-    display: flex;
-    align-items: center;
-    gap: var(--ntl-space-2xs);
-  }
-
-  .copy-actions-action {
-    display: flex;
-    align-items: center;
-    gap: var(--ntl-space-3xs);
-    background: none;
-    border: none;
-    padding: 0;
-    font: inherit;
-    color: var(--ntl-color-text-weak);
-    cursor: pointer;
-  }
-
-  .copy-actions-label {
-    font-size: var(--ntl-font-size-text-sm);
-  }
-
-  .copy-actions-icon {
-    width: var(--ntl-space-s);
-    height: var(--ntl-space-s);
-  }
-
-  .copy-actions-copy-url::after {
-    content: '•';
-    margin-inline-start: var(--ntl-space-2xs);
-  }
-
-  .copy-actions-action:hover {
-    color: var(--ntl-color-text);
-  }
-</style>
-
-<script>
-  import { initArticleCopyActions } from './articleCopyActions';
-
-  // `astro:page-load` fires on the initial load *and* after every client-side
-  // navigation (`<ClientRouter />`).
-  document.addEventListener('astro:page-load', () => initArticleCopyActions());
-</script>

package/packages/components/articleCopyActions.test.ts

@@ -1,143 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { initArticleCopyActions } from './articleCopyActions';
-
-const ARTICLE_URL = 'https://www.netlify.com/blog/some-post/';
-const MARKDOWN = '# Some post\n\nBody content.';
-
-function renderCopyActions({ url = ARTICLE_URL, markdown = MARKDOWN, copiedLabel = 'Copied!' } = {}) {
-  document.body.innerHTML = `
-    <div class="copy-actions" data-copied-label="${copiedLabel}">
-      <button
-        type="button"
-        class="copy-actions-action copy-actions-copy-url"
-        data-copy="url"
-        data-value="${url}"
-      >
-        <span>Copy URL</span>
-      </button>
-      <button
-        type="button"
-        class="copy-actions-action copy-actions-copy-content"
-        data-copy="page"
-      >
-        <span>Copy page</span>
-      </button>
-    </div>
-    <script type="text/plain" data-copy-actions-source>${markdown}</script>
-  `;
-
-  return {
-    wrapper: document.querySelector<HTMLElement>('.copy-actions')!,
-    copyUrlBtn: document.querySelector<HTMLButtonElement>('.copy-actions-copy-url')!,
-    copyPageBtn: document.querySelector<HTMLButtonElement>('.copy-actions-copy-content')!,
-    urlLabel: document.querySelector<HTMLElement>('.copy-actions-copy-url span')!,
-    pageLabel: document.querySelector<HTMLElement>('.copy-actions-copy-content span')!,
-  };
-}
-
-describe('initArticleCopyActions', () => {
-  let writeText: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    writeText = vi.fn().mockResolvedValue(undefined);
-    Object.defineProperty(navigator, 'clipboard', {
-      value: { writeText },
-      configurable: true,
-    });
-  });
-
-  afterEach(() => {
-    vi.runOnlyPendingTimers();
-    vi.useRealTimers();
-    document.body.innerHTML = '';
-  });
-
-  it('copies the article URL and shows a temporary confirmation', async () => {
-    const { copyUrlBtn, urlLabel } = renderCopyActions();
-    initArticleCopyActions();
-
-    copyUrlBtn.click();
-    await vi.waitFor(() => expect(writeText).toHaveBeenCalledWith(ARTICLE_URL));
-    expect(urlLabel.textContent).toBe('Copied!');
-  });
-
-  it('copies the markdown source for the "Copy page" button', async () => {
-    const { copyPageBtn, pageLabel } = renderCopyActions();
-    initArticleCopyActions();
-
-    copyPageBtn.click();
-    await vi.waitFor(() => expect(writeText).toHaveBeenCalledWith(MARKDOWN));
-    expect(pageLabel.textContent).toBe('Copied!');
-  });
-
-  it('resets the label back to its original text after the delay', async () => {
-    const { copyUrlBtn, urlLabel } = renderCopyActions();
-    initArticleCopyActions();
-
-    copyUrlBtn.click();
-    await vi.waitFor(() => expect(urlLabel.textContent).toBe('Copied!'));
-
-    vi.advanceTimersByTime(1500);
-    expect(urlLabel.textContent).toBe('Copy URL');
-  });
-
-  it('uses a custom copied label when data-copied-label is set', async () => {
-    const { copyUrlBtn, urlLabel } = renderCopyActions({ copiedLabel: 'Done!' });
-    initArticleCopyActions();
-
-    copyUrlBtn.click();
-    await vi.waitFor(() => expect(urlLabel.textContent).toBe('Done!'));
-  });
-
-  it('does not attach duplicate listeners when initialised twice on the same DOM', async () => {
-    const { copyUrlBtn } = renderCopyActions();
-    initArticleCopyActions();
-    initArticleCopyActions(); // e.g. a spurious re-fire
-
-    copyUrlBtn.click();
-    await vi.waitFor(() => expect(writeText).toHaveBeenCalledTimes(1));
-  });
-
-  it('re-binds after a client-side navigation swaps in fresh buttons', async () => {
-    // Simulate the ClientRouter bug: first page loads and works...
-    const first = renderCopyActions({ url: 'https://example.com/first/' });
-    initArticleCopyActions();
-    first.copyUrlBtn.click();
-    await vi.waitFor(() => expect(writeText).toHaveBeenCalledWith('https://example.com/first/'));
-
-    // ...then a navigation replaces the DOM with a new post's buttons.
-    const second = renderCopyActions({ url: 'https://example.com/second/' });
-    // Re-running on `astro:page-load` is what makes the new buttons work.
-    initArticleCopyActions();
-
-    second.copyUrlBtn.click();
-    await vi.waitFor(() => expect(writeText).toHaveBeenCalledWith('https://example.com/second/'));
-  });
-
-  it('scopes the markdown source lookup to each wrapper, not a global selector', async () => {
-    document.body.innerHTML = `
-      <div class="copy-actions" data-copied-label="Copied!">
-        <button type="button" class="copy-actions-action copy-actions-copy-content" data-copy="page">
-          <span>Copy page</span>
-        </button>
-      </div>
-      <script type="text/plain" data-copy-actions-source>First post markdown</script>
-      <div class="copy-actions" data-copied-label="Copied!">
-        <button type="button" class="copy-actions-action copy-actions-copy-content" data-copy="page">
-          <span>Copy page</span>
-        </button>
-      </div>
-      <script type="text/plain" data-copy-actions-source>Second post markdown</script>
-    `;
-    initArticleCopyActions();
-
-    const buttons = document.querySelectorAll<HTMLButtonElement>('.copy-actions-copy-content');
-    buttons[1].click();
-    await vi.waitFor(() => expect(writeText).toHaveBeenCalledWith('Second post markdown'));
-
-    buttons[0].click();
-    await vi.waitFor(() => expect(writeText).toHaveBeenCalledWith('First post markdown'));
-  });
-});

package/packages/components/articleCopyActions.ts

@@ -1,41 +0,0 @@
-const COPIED_LABEL_FALLBACK = 'Copied!';
-const RESET_DELAY_MS = 1500;
-
-/**
- * Wire up the "Copy URL" / "Copy page" buttons rendered by ArticleCopyActions.astro.
- *
- * This runs on every `astro:page-load` (initial load *and* every client-side
- * navigation via `<ClientRouter />`), so the buttons keep working after routing
- * to another article/post. Each wrapper is guarded so re-initialising the same
- * DOM node never attaches duplicate listeners.
- */
-export function initArticleCopyActions(root: ParentNode = document): void {
-  root.querySelectorAll<HTMLElement>('.copy-actions').forEach(wrapper => {
-    if (wrapper.dataset.copyBound === 'true') return;
-    wrapper.dataset.copyBound = 'true';
-
-    const source = wrapper.nextElementSibling as HTMLElement | null;
-    const copiedLabel = wrapper.dataset.copiedLabel ?? COPIED_LABEL_FALLBACK;
-
-    wrapper.querySelectorAll<HTMLButtonElement>('.copy-actions-action').forEach(btn => {
-      const label = btn.querySelector<HTMLElement>('span');
-      const originalText = label?.textContent;
-
-      btn.addEventListener('click', async () => {
-        const value =
-          btn.getAttribute('data-copy') === 'url'
-            ? btn.getAttribute('data-value')
-            : source?.textContent;
-
-        if (!value || !label) return;
-
-        await navigator.clipboard.writeText(value);
-
-        label.textContent = copiedLabel;
-        setTimeout(() => {
-          label.textContent = originalText ?? '';
-        }, RESET_DELAY_MS);
-      });
-    });
-  });
-}