npm - @agent-native/core - Versions diffs - 0.80.2 → 0.80.5 - Mend

@agent-native/core 0.80.2 → 0.80.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (322) hide show

package/corpus/templates/design/e2e/global-setup.ts ADDED Viewed

@@ -0,0 +1,157 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { chromium, type FullConfig } from "@playwright/test";
+/**
+ * Global setup: authenticate a test user (email/password; there is no dev auth
+ * bypass) and seed one design with a known fixture HTML so specs run against
+ * deterministic content. Writes:
+ *   e2e/.auth/state.json  - signed session storageState
+ *   e2e/.auth/seed.json   - { designId } of the seeded design
+ */
+export const E2E_EMAIL = "e2e@local.test";
+export const E2E_PASSWORD = "password-e2e-1234";
+export const SEED_TITLE = "E2E Seed Design";
+const AUTH_DIR = path.join(import.meta.dirname, ".auth");
+const STATE_PATH = path.join(AUTH_DIR, "state.json");
+const SEED_PATH = path.join(AUTH_DIR, "seed.json");
+/**
+ * Fixture HTML with distinct, text-identifiable elements. Plain inline styles
+ * (no CDN) so the layout is deterministic and offline. The flex row of two
+ * buttons exercises reorder/move; headings and paragraphs exercise select.
+ */
+export const FIXTURE_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>E2E Fixture</title>
+  </head>
+  <body style="margin:0;font-family:system-ui,sans-serif;background:#0f1115;color:#f4f4f5">
+    <main style="max-width:720px;margin:0 auto;padding:48px 32px;display:flex;flex-direction:column;gap:24px">
+      <h1 style="font-size:40px;font-weight:800;margin:0">E2E Hero Heading</h1>
+      <p style="font-size:18px;line-height:1.6;margin:0;color:#a1a1aa">First fixture paragraph for selection tests.</p>
+      <p style="font-size:18px;line-height:1.6;margin:0;color:#a1a1aa">Second fixture paragraph for selection tests.</p>
+      <div style="display:flex;flex-direction:row;gap:16px">
+        <button style="padding:14px 28px;border-radius:10px;border:0;background:#6366f1;color:#fff;font-size:16px">Alpha Button</button>
+        <button style="padding:14px 28px;border-radius:10px;border:0;background:#22c55e;color:#06240f;font-size:16px">Beta Button</button>
+      </div>
+      <section style="margin-top:16px;padding:24px;border-radius:14px;background:#1a1d24">
+        <h2 style="font-size:24px;margin:0 0 8px">Fixture Card Title</h2>
+        <p style="margin:0;color:#a1a1aa">Card body text inside a nested container.</p>
+      </section>
+    </main>
+  </body>
+</html>`;
+async function postAction(
+  request: import("@playwright/test").APIRequestContext,
+  baseURL: string,
+  name: string,
+  input: Record<string, unknown>,
+): Promise<any> {
+  const res = await request.post(`${baseURL}/_agent-native/actions/${name}`, {
+    data: input,
+    headers: { "Content-Type": "application/json" },
+  });
+  if (!res.ok()) {
+    throw new Error(
+      `action ${name} failed: ${res.status()} ${await res.text()}`,
+    );
+  }
+  return res.json();
+}
+export default async function globalSetup(config: FullConfig) {
+  const baseURL =
+    (config.projects[0]?.use?.baseURL as string | undefined) ??
+    "http://127.0.0.1:9333";
+  await mkdir(AUTH_DIR, { recursive: true });
+  const browser = await chromium.launch();
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  try {
+    await page.goto(`${baseURL}/`, { waitUntil: "domcontentloaded" });
+    const isSignIn = async () => /sign in/i.test(await page.title());
+    if (await isSignIn()) {
+      // Try to create the account; if it already exists, fall back to sign in.
+      await page.getByRole("textbox", { name: "Email" }).fill(E2E_EMAIL);
+      await page
+        .getByRole("textbox", { name: "Password", exact: true })
+        .fill(E2E_PASSWORD);
+      const confirm = page.getByRole("textbox", { name: "Confirm password" });
+      if (await confirm.count()) await confirm.fill(E2E_PASSWORD);
+      await page
+        .locator("#signup-form")
+        .getByRole("button", { name: "Create account" })
+        .click()
+        .catch(() => {});
+      await page.waitForTimeout(2500);
+      if (await isSignIn()) {
+        // Account exists; switch to the Sign in tab and log in.
+        await page
+          .getByRole("button", { name: "Sign in", exact: true })
+          .first()
+          .click()
+          .catch(() => {});
+        await page.getByRole("textbox", { name: "Email" }).fill(E2E_EMAIL);
+        await page
+          .getByRole("textbox", { name: "Password", exact: true })
+          .fill(E2E_PASSWORD);
+        await page
+          .getByRole("button", { name: /sign in/i })
+          .last()
+          .click()
+          .catch(() => {});
+        await page.waitForTimeout(2500);
+      }
+    }
+    await page
+      .waitForFunction(() => !/sign in/i.test(document.title), null, {
+        timeout: 20_000,
+      })
+      .catch(() => {});
+    await context.storageState({ path: STATE_PATH });
+    // Seed a design + fixture file via the authenticated action surface.
+    const created = await postAction(
+      context.request,
+      baseURL,
+      "create-design",
+      {
+        title: SEED_TITLE,
+        projectType: "prototype",
+      },
+    );
+    const designId: string =
+      created?.id ?? created?.data?.id ?? created?.design?.id;
+    if (!designId) {
+      throw new Error(
+        `create-design did not return an id: ${JSON.stringify(created)}`,
+      );
+    }
+    await postAction(context.request, baseURL, "create-file", {
+      designId,
+      filename: "index.html",
+      content: FIXTURE_HTML,
+      fileType: "html",
+    });
+    await writeFile(SEED_PATH, JSON.stringify({ designId }, null, 2));
+    // eslint-disable-next-line no-console
+    console.log(`[e2e] seeded design ${designId} for ${E2E_EMAIL}`);
+  } finally {
+    await browser.close();
+  }
+}

package/corpus/templates/design/e2e/helpers.ts ADDED Viewed

@@ -0,0 +1,148 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { expect, type Page, type FrameLocator } from "@playwright/test";
+/**
+ * Helpers for driving the Design visual editor in real Chrome.
+ *
+ * Hard-won facts for this editor:
+ *  - The design renders inside an iframe, so tests should use a frame locator
+ *    (`page.frameLocator('iframe')`) instead of parent-page CSS selectors.
+ *  - A pointer-capturing shield `<div data-agent-native-edit-overlay="shield">`
+ *    sits on top inside the iframe, so clicks need `{ force: true }`.
+ *  - Selection/edits are reported to the parent via postMessage
+ *    (`element-select`, `element-hover`, `visual-style-change`,
+ *    `visual-structure-change`). Assert on those + the parent inspector DOM.
+ *  - `page.screenshot()` HANGS (the page never idles). Use `cdpScreenshot()`.
+ */
+export async function readSeedDesignId(): Promise<string> {
+  const seedPath = path.join(import.meta.dirname, ".auth", "seed.json");
+  const raw = await readFile(seedPath, "utf8");
+  const { designId } = JSON.parse(raw) as { designId: string };
+  if (!designId) throw new Error("no seeded designId - global-setup failed");
+  return designId;
+}
+export function designFrame(page: Page): FrameLocator {
+  return page.frameLocator("iframe");
+}
+/** Open the editor for a design and wait for the toolbar + iframe to be ready. */
+export async function gotoEditor(page: Page, designId: string): Promise<void> {
+  await page.goto(`/design/${designId}`, { waitUntil: "domcontentloaded" });
+  await expect(
+    page.getByRole("button", { name: "Move", exact: true }),
+  ).toBeVisible({ timeout: 30_000 });
+  await expect(page.locator("iframe").first()).toBeVisible();
+  // Wait for the iframe bridge to stamp at least one selectable node.
+  await expect
+    .poll(
+      async () =>
+        designFrame(page)
+          .locator("[data-agent-native-node-id], h1, h2, p, button")
+          .count(),
+      { timeout: 20_000 },
+    )
+    .toBeGreaterThan(0);
+}
+/** Start capturing bridge postMessages on the parent window. */
+export async function installBridge(page: Page): Promise<void> {
+  await page.evaluate(() => {
+    (window as any).__bridge = [];
+    window.addEventListener("message", (e: MessageEvent) => {
+      const t = (e.data as any)?.type;
+      if (typeof t === "string" && /^(element-|visual-)/.test(t)) {
+        (window as any).__bridge.push(e.data);
+      }
+    });
+  });
+}
+export async function bridgeMessages(page: Page): Promise<any[]> {
+  return page.evaluate(() => (window as any).__bridge ?? []);
+}
+/** Wait until a bridge message of `type` arrives, returning its payload. */
+export async function waitForBridge(
+  page: Page,
+  type: string,
+  timeout = 8_000,
+): Promise<any> {
+  const handle = await page.waitForFunction(
+    (t) =>
+      ((window as any).__bridge ?? []).find((m: any) => m.type === t) ?? null,
+    type,
+    { timeout },
+  );
+  return handle.jsonValue();
+}
+/**
+ * Click an element inside the design iframe by its visible text and return the
+ * resulting `element-select` payload. Uses force:true to punch through the
+ * shield overlay (which is what actually drives selection).
+ */
+export async function selectByText(page: Page, text: string): Promise<any> {
+  await installBridge(page);
+  await page.evaluate(() => ((window as any).__bridge = []));
+  await designFrame(page)
+    .getByText(text, { exact: false })
+    .first()
+    .click({ force: true, timeout: 8_000 });
+  const sel = await waitForBridge(page, "element-select");
+  return sel?.payload ?? sel;
+}
+/** Number of inputs in the right-hand inspector (proxy for "inspector populated"). */
+export async function inspectorInputCount(page: Page): Promise<number> {
+  return page.locator("input").count();
+}
+/**
+ * Drag an element inside the iframe by `(dx, dy)` parent-page pixels using real
+ * pointer events (the canvas bridge handles mousedown/mousemove/mouseup).
+ * Selects it first so the move/reorder interaction is armed.
+ */
+export async function dragCanvasByText(
+  page: Page,
+  text: string,
+  dx: number,
+  dy: number,
+): Promise<string[]> {
+  await selectByText(page, text);
+  await page.evaluate(() => ((window as any).__bridge = []));
+  const box = await designFrame(page)
+    .getByText(text, { exact: false })
+    .first()
+    .boundingBox();
+  if (!box) throw new Error(`no bounding box for "${text}"`);
+  const cx = box.x + box.width / 2;
+  const cy = box.y + box.height / 2;
+  await page.mouse.move(cx, cy);
+  await page.mouse.down();
+  const steps = 10;
+  for (let i = 1; i <= steps; i++) {
+    await page.mouse.move(cx + (dx * i) / steps, cy + (dy * i) / steps);
+  }
+  await page.waitForTimeout(150);
+  await page.mouse.up();
+  await page.waitForTimeout(400);
+  const msgs = await bridgeMessages(page);
+  return [...new Set(msgs.map((m) => m.type))];
+}
+/** Screenshot via CDP; bypasses Playwright's stability wait, which never settles. */
+export async function cdpScreenshot(
+  page: Page,
+  filePath: string,
+): Promise<void> {
+  const client = await page.context().newCDPSession(page);
+  const { data } = await client.send("Page.captureScreenshot", {
+    format: "png",
+  });
+  const { writeFile } = await import("node:fs/promises");
+  await writeFile(filePath, Buffer.from(data, "base64"));
+}

package/corpus/templates/design/netlify.toml CHANGED Viewed

@@ -8,10 +8,9 @@ functions = "templates/design/.netlify/functions-internal"
 GA_MEASUREMENT_ID = "G-ESF7FYXGN9"
 NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
+AGENT_CHAT_DURABLE_BACKGROUND = "true"
-# A2A delegation calls run a full agent loop (LLM + tool calls + DB queries).
-# The framework does not impose a default agent-run timeout; if a template sets
-# AGENT_RUN_SOFT_TIMEOUT_MS, keep it below this function timeout so the hidden
-# auto-continuation path can hand off before Netlify kills the function.
+# Emit the Netlify background function used by Design's durable agent-chat opt-in.
+# The normal server timeout still protects non-background HTTP handlers.
 [functions."*"]
 timeout = 75

package/corpus/templates/design/package.json CHANGED Viewed

@@ -10,7 +10,10 @@
     "test": "vitest --run",
     "typecheck": "agent-native typecheck",
     "action": "agent-native action",
-    "script": "agent-native script"
+    "script": "agent-native script",
+    "e2e": "playwright test",
+    "e2e:headed": "playwright test --headed",
+    "e2e:ui": "playwright test --ui"
   },
   "dependencies": {
     "@agent-native/core": "workspace:*",
@@ -31,6 +34,7 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@playwright/test": "^1.61.1",
     "@radix-ui/react-accordion": "^1.2.12",
     "@radix-ui/react-alert-dialog": "^1.1.15",
     "@radix-ui/react-aspect-ratio": "^1.1.8",

package/corpus/templates/design/playwright.config.ts ADDED Viewed

@@ -0,0 +1,51 @@
+import path from "node:path";
+import { defineConfig, devices } from "@playwright/test";
+/**
+ * E2E config for the Design visual editor.
+ *
+ * Runs real Chromium against a dev server backed by a throwaway local SQLite
+ * database (`data/e2e.db`). `global-setup.ts` signs up a test user, saves the
+ * signed session as `storageState`, and seeds one design with a known fixture.
+ *
+ * Run: `pnpm e2e` (headless), `pnpm e2e:headed`, `pnpm e2e:ui`.
+ * Override the target with `E2E_BASE_URL` (e.g. point at an already-running
+ * server on :9300); then `webServer.reuseExistingServer` keeps it.
+ */
+const PORT = Number(process.env.E2E_PORT ?? 9333);
+const BASE_URL = process.env.E2E_BASE_URL ?? `http://127.0.0.1:${PORT}`;
+export default defineConfig({
+  testDir: "./e2e",
+  // The editor is heavy (iframe bridge + polling); give generous budgets.
+  timeout: 90_000,
+  expect: { timeout: 15_000 },
+  fullyParallel: false,
+  workers: 1,
+  retries: process.env.CI ? 1 : 0,
+  reporter: process.env.CI ? "github" : "list",
+  globalSetup: path.join(import.meta.dirname, "e2e", "global-setup.ts"),
+  use: {
+    baseURL: BASE_URL,
+    storageState: path.join(import.meta.dirname, "e2e", ".auth", "state.json"),
+    trace: "on-first-retry",
+    actionTimeout: 15_000,
+    navigationTimeout: 30_000,
+  },
+  projects: [{ name: "chromium", use: { ...devices["Desktop Chrome"] } }],
+  webServer: process.env.E2E_BASE_URL
+    ? undefined
+    : {
+        // APP_NAME + the app-prefixed DESIGN_DATABASE_URL is checked BEFORE the
+        // generic DATABASE_URL, so a `.env` Postgres URL can never override this
+        // throwaway local SQLite db.
+        command: `APP_NAME=design DESIGN_DATABASE_URL="file:./data/e2e.db" PORT=${PORT} pnpm dev`,
+        url: BASE_URL,
+        reuseExistingServer: !process.env.CI,
+        // Cold Vite dep-optimization on first boot can exceed two minutes.
+        timeout: 300_000,
+        stdout: "ignore",
+        stderr: "pipe",
+      },
+});

package/corpus/templates/design/server/handlers/index-design-system-with-builder.ts ADDED Viewed

@@ -0,0 +1,121 @@
+import {
+  FeatureNotConfiguredError,
+  getSession,
+  startBuilderDesignSystemIndex,
+} from "@agent-native/core/server";
+import {
+  defineEventHandler,
+  getRequestHeader,
+  readMultipartFormData,
+  setResponseStatus,
+} from "h3";
+import { upsertBuilderProxyDesignSystem } from "../lib/builder-design-system-proxy.js";
+const MAX_FIG_BYTES = 200 * 1024 * 1024;
+const MULTIPART_OVERHEAD_BYTES = 1024 * 1024;
+function requestContentLength(event: Parameters<typeof getRequestHeader>[0]) {
+  const raw = getRequestHeader(event, "content-length");
+  if (!raw) return null;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+/**
+ * Builder-indexing endpoint: accepts a `.fig` upload (multipart field `file`)
+ * and starts Builder's design-system indexing pipeline. The app does not decode
+ * Figma files locally; Builder owns extraction, generated docs, and the
+ * asynchronous indexing job.
+ */
+export const indexDesignSystemWithBuilder = defineEventHandler(
+  async (event) => {
+    const session = await getSession(event).catch(() => null);
+    if (!session?.email) {
+      setResponseStatus(event, 401);
+      return { error: "Unauthorized" };
+    }
+    const contentLength = requestContentLength(event);
+    if (
+      contentLength !== null &&
+      contentLength > MAX_FIG_BYTES + MULTIPART_OVERHEAD_BYTES
+    ) {
+      setResponseStatus(event, 413);
+      return {
+        error: `File too large (max ${Math.round(MAX_FIG_BYTES / 1024 / 1024)} MB).`,
+      };
+    }
+    let parts;
+    try {
+      parts = await readMultipartFormData(event);
+    } catch {
+      setResponseStatus(event, 413);
+      return { error: "Upload too large or malformed." };
+    }
+    const part = parts?.find(
+      (p) => (p.name === "file" || p.name === "fig") && p.data,
+    );
+    if (!part) {
+      setResponseStatus(event, 400);
+      return {
+        error: "No .fig file uploaded (expected multipart field 'file').",
+      };
+    }
+    if (part.data.length > MAX_FIG_BYTES) {
+      setResponseStatus(event, 413);
+      return {
+        error: `File too large (max ${Math.round(MAX_FIG_BYTES / 1024 / 1024)} MB).`,
+      };
+    }
+    const suggestedTitle =
+      (part.filename || "Imported brand")
+        .replace(/\.fig$/i, "")
+        .replace(/[-_]+/g, " ")
+        .trim() || "Imported brand";
+    try {
+      const result = await startBuilderDesignSystemIndex({
+        projectName: suggestedTitle,
+        files: [
+          {
+            name: part.filename || "brand.fig",
+            data: part.data,
+            mimeType: "application/octet-stream",
+          },
+        ],
+      });
+      const proxy = await upsertBuilderProxyDesignSystem({
+        result,
+        ownerEmail: session.email,
+        orgId: session.orgId ?? null,
+        projectName: suggestedTitle,
+      });
+      return {
+        ...result,
+        ...proxy,
+        uploadedFileCount: 1,
+      };
+    } catch (err) {
+      if (err instanceof FeatureNotConfiguredError) {
+        setResponseStatus(event, 412);
+        return {
+          error:
+            err.message ||
+            "Connect Builder.io before indexing a design system from Figma.",
+          builderConnectUrl:
+            err.builderConnectUrl ?? "/_agent-native/builder/connect",
+        };
+      }
+      setResponseStatus(event, 502);
+      return {
+        error:
+          err instanceof Error
+            ? err.message
+            : "Builder design-system indexing failed.",
+      };
+    }
+  },
+);

package/corpus/templates/design/server/handlers/uploads.ts CHANGED Viewed

@@ -5,6 +5,7 @@ import path from "path";
 import { getSession } from "@agent-native/core/server";
 import {
   defineEventHandler,
+  getRequestHeader,
   readMultipartFormData,
   setResponseStatus,
 } from "h3";
@@ -132,6 +133,20 @@ async function extractUploadText(
   return {};
 }
+type UploadedFileResult = {
+  path: string;
+  originalName: string;
+  filename: string;
+  type: string;
+  size: number;
+  textContent?: string;
+  textTruncated?: boolean;
+};
+type InternalUploadedFileResult = UploadedFileResult & {
+  _destPath: string;
+};
 export const uploadFiles = defineEventHandler(async (event) => {
   const session = await getSession(event).catch(() => null);
   if (!session?.email) {
@@ -139,6 +154,21 @@ export const uploadFiles = defineEventHandler(async (event) => {
     return { error: "Unauthorized" };
   }
+  const MAX_FILES = 20;
+  const MAX_FILE_SIZE = 50 * 1024 * 1024;
+  // Total-body pre-flight: reject before buffering if Content-Length is clearly
+  // over the theoretical max (MAX_FILES × MAX_FILE_SIZE each, plus overhead).
+  // Content-Length can be spoofed but cheaply eliminates accidental oversized
+  // uploads without allocating any memory for the body first.
+  const TOTAL_BODY_LIMIT = MAX_FILES * MAX_FILE_SIZE;
+  const contentLength = Number(
+    getRequestHeader(event, "content-length") ?? "0",
+  );
+  if (contentLength > TOTAL_BODY_LIMIT) {
+    setResponseStatus(event, 413);
+    return { error: "Request body too large" };
+  }
   const parts = await readMultipartFormData(event);
   const fileParts = parts?.filter((p) => p.name === "files" && p.data) ?? [];
@@ -147,9 +177,6 @@ export const uploadFiles = defineEventHandler(async (event) => {
     return { error: "No files uploaded" };
   }
-  const MAX_FILES = 20;
-  const MAX_FILE_SIZE = 50 * 1024 * 1024;
   if (fileParts.length > MAX_FILES) {
     setResponseStatus(event, 413);
     return { error: `Too many files (max ${MAX_FILES})` };
@@ -161,41 +188,65 @@ export const uploadFiles = defineEventHandler(async (event) => {
     return { error: "File too large (max 50 MB per file)" };
   }
-  try {
-    return await Promise.all(
-      fileParts.map(async (part) => {
-        const originalName = part.filename || "upload";
-        const filename = safeFilename(originalName);
-        if (!filename) {
-          throw new Error(
-            "Unsupported file type. Allowed: code, docs, text, JSON, CSV, and raster images.",
-          );
-        }
-        const ext = path.extname(filename).toLowerCase();
-        if (!hasExpectedSignature(ext, part.data)) {
-          throw new Error(`File contents do not match ${ext} upload type`);
-        }
-        const uploadDir = tenantUploadDir(session.email);
-        await fs.promises.mkdir(uploadDir, { recursive: true });
-        const destPath = path.join(uploadDir, filename);
-        await fs.promises.writeFile(destPath, part.data);
-        const extracted = await extractUploadText(ext, part.data);
-        return {
-          path: path
-            .relative(process.cwd(), destPath)
-            .split(path.sep)
-            .join("/"),
-          originalName,
-          filename,
-          type: part.type || "application/octet-stream",
-          size: part.data.length,
-          ...extracted,
-        };
-      }),
-    );
-  } catch (err) {
+  const results = await Promise.allSettled<InternalUploadedFileResult>(
+    fileParts.map(async (part) => {
+      const originalName = part.filename || "upload";
+      const filename = safeFilename(originalName);
+      if (!filename) {
+        throw new Error(
+          "Unsupported file type. Allowed: code, docs, text, JSON, CSV, and raster images.",
+        );
+      }
+      const ext = path.extname(filename).toLowerCase();
+      if (!hasExpectedSignature(ext, part.data)) {
+        throw new Error(`File contents do not match ${ext} upload type`);
+      }
+      const uploadDir = tenantUploadDir(session.email);
+      await fs.promises.mkdir(uploadDir, { recursive: true });
+      const destPath = path.join(uploadDir, filename);
+      await fs.promises.writeFile(destPath, part.data);
+      const extracted = await extractUploadText(ext, part.data);
+      return {
+        // Return the filename (nanoid + ext) as the opaque path token rather
+        // than the internal filesystem path so we don't expose the server
+        // directory layout or per-tenant hash to the client.
+        path: filename,
+        originalName,
+        filename,
+        type: part.type || "application/octet-stream",
+        size: part.data.length,
+        ...extracted,
+        _destPath: destPath,
+      };
+    }),
+  );
+  const failures = results.filter((r) => r.status === "rejected");
+  if (failures.length > 0) {
+    // Clean up any files that were successfully written before the failure.
+    const writtenPaths = results
+      .filter((r) => r.status === "fulfilled")
+      .map(
+        (r) =>
+          (r as PromiseFulfilledResult<InternalUploadedFileResult>).value
+            ._destPath,
+      );
+    await Promise.allSettled(writtenPaths.map((p) => fs.promises.unlink(p)));
+    const firstError = (failures[0] as PromiseRejectedResult).reason;
     setResponseStatus(event, 400);
-    return { error: err instanceof Error ? err.message : "Invalid upload" };
+    return {
+      error:
+        firstError instanceof Error ? firstError.message : "Invalid upload",
+    };
   }
+  // Strip the internal _destPath field before returning to the client.
+  return results.map((r) => {
+    const { _destPath: _unused, ...rest } = (
+      r as PromiseFulfilledResult<InternalUploadedFileResult>
+    ).value;
+    return rest;
+  });
 });