@podosoft/podokit 1.3.0 → 1.4.0

package/dist/templates/modules/jobs-local/module.manifest.json

@@ -8,6 +8,9 @@
     "apps/api/src/config/providers.ts",
     "apps/api/src/database/database.ts"
   ],
+  "requiredProjectContents": {
+    "apps/api/src/core/services.ts": ["supervise(name: string, connection: SupervisedConnection): void {"]
+  },
   "managedGlobs": [
     "apps/api/src/jobs-local/**"
   ],

package/dist/templates/modules/object-storage-local/files/apps/api/src/storage-local/download-url.ts

@@ -2,8 +2,11 @@ import { createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypt
 import { link, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import type {
+  CompletedPart,
+  CreateMultipartUploadOptions,
   DownloadUrlOptions,
   ListObjectsOptions,
+  MultipartUpload,
   ObjectBody,
   ObjectData,
   ObjectInfo,
@@ -11,6 +14,7 @@ import type {
   ObjectStore,
   PutObjectOptions,
   StoredObject,
+  UploadedPart,
 } from "@podosoft/podokit-runtime";
 
 const KEY_BYTES = 32;
@@ -153,6 +157,22 @@ export class SignedDownloadStore implements ObjectStore {
     return `${path}?${new URLSearchParams({ expires, signature }).toString()}`;
   }
 
+  createMultipartUpload(key: string, options?: CreateMultipartUploadOptions): Promise<MultipartUpload> {
+    return this.store.createMultipartUpload(key, options);
+  }
+
+  uploadPart(key: string, uploadId: string, partNumber: number, body: ObjectBody): Promise<UploadedPart> {
+    return this.store.uploadPart(key, uploadId, partNumber, body);
+  }
+
+  completeMultipartUpload(key: string, uploadId: string, parts: readonly CompletedPart[]): Promise<ObjectInfo> {
+    return this.store.completeMultipartUpload(key, uploadId, parts);
+  }
+
+  abortMultipartUpload(key: string, uploadId: string): Promise<void> {
+    return this.store.abortMultipartUpload(key, uploadId);
+  }
+
   close(): void | Promise<void> {
     return this.store.close();
   }

package/dist/templates/modules/object-storage-local/files/apps/api/src/storage-local/storage-local.module.spec.ts

@@ -1,14 +1,20 @@
 import { afterEach, describe, expect, it } from "bun:test";
+import { randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { AppException } from "@podosoft/podokit-contracts";
-import { LocalObjectStore } from "@podosoft/podokit-runtime";
+import { IN_MEMORY_READ_BYTES, LocalObjectStore } from "@podosoft/podokit-runtime";
 import { Elysia } from "elysia";
 import type { RequestIdentity } from "../core/services";
 import { DownloadUrlSigner, SignedDownloadStore } from "./download-url";
-import { DOWNLOAD_BASE_URL, downloadSafetyHeaders, localStorageRoutes } from "./storage-local.module";
+import {
+  DOWNLOAD_BASE_URL,
+  downloadSafetyHeaders,
+  localStorageRoutes,
+  multipartMaxAgeMs,
+} from "./storage-local.module";
 
 let root: string | undefined;
 
@@ -51,15 +57,12 @@ interface Reply {
   headers: Headers;
 }
 
-async function call(
-  { storage, signer }: Fixture,
-  identity: RequestIdentity,
-  method: "GET" | "PUT",
-  path: string,
-  content?: string,
-  headers: Record<string, string> = {},
-): Promise<Reply> {
-  const app = new Elysia()
+interface Handler {
+  handle(request: Request): Promise<Response>;
+}
+
+function routes({ storage, signer }: Fixture, identity: RequestIdentity): Handler {
+  return new Elysia()
     .onError(({ code, error, set }) => {
       if (error instanceof AppException) {
         set.status = error.statusCode;
@@ -76,7 +79,17 @@ async function call(
       return undefined;
     })
     .use(localStorageRoutes(storage, signer, identity));
-  const response = await app.handle(new Request(`http://localhost${path}`, {
+}
+
+async function call(
+  local: Fixture,
+  identity: RequestIdentity,
+  method: "GET" | "PUT",
+  path: string,
+  content?: string,
+  headers: Record<string, string> = {},
+): Promise<Reply> {
+  const response = await routes(local, identity).handle(new Request(`http://localhost${path}`, {
     method,
     headers: { ...(content === undefined ? {} : { "content-type": "application/json" }), ...headers },
     ...(content === undefined ? {} : { body: JSON.stringify({ content }) }),
@@ -133,6 +146,31 @@ describe("local object storage provider", () => {
     expect(code(missing)).toBe("STORAGE_OBJECT_NOT_FOUND");
   });
 
+  it("serves objects through Bun with the Content-Length of those read into memory", async () => {
+    const local = await fixture();
+    const app = routes(local, caller(undefined));
+    const server = Bun.serve({ port: 0, fetch: (request) => app.handle(request) });
+    try {
+      for (const size of [68, 100 * 1024, IN_MEMORY_READ_BYTES, IN_MEMORY_READ_BYTES + 1]) {
+        const content = randomBytes(size);
+        const key = `uploads/served-${size}.bin`;
+        await local.storage.put(key, content, { contentType: "image/png" });
+        const response = await fetch(new URL(await local.storage.getDownloadUrl(key), server.url));
+        expect(response.status).toBe(200);
+        if (size <= IN_MEMORY_READ_BYTES) {
+          expect(response.headers.get("content-length")).toBe(String(size));
+          expect(response.headers.get("transfer-encoding")).toBeNull();
+        } else {
+          // Streamed from the file, which Bun may send chunked; a length must still be right.
+          expect(response.headers.get("content-length") ?? String(size)).toBe(String(size));
+        }
+        expect(Buffer.from(await response.arrayBuffer()).equals(content)).toBe(true);
+      }
+    } finally {
+      server.stop(true);
+    }
+  });
+
   it("limits the demo routes to administrators", async () => {
     const local = await fixture();
 
@@ -176,6 +214,35 @@ describe("local object storage provider", () => {
   });
 });
 
+describe("local multipart uploads", () => {
+  it("assembles an object from parts through the signed store", async () => {
+    const local = await fixture();
+    const { uploadId } = await local.storage.createMultipartUpload("uploads/big.txt", { contentType: "text/plain" });
+    const second = await local.storage.uploadPart("uploads/big.txt", uploadId, 2, "world");
+    const first = await local.storage.uploadPart("uploads/big.txt", uploadId, 1, new Blob(["x".repeat(5 * 1024 * 1024)]));
+    const info = await local.storage.completeMultipartUpload("uploads/big.txt", uploadId, [
+      { partNumber: 1, etag: first.etag },
+      { partNumber: 2, etag: second.etag },
+    ]);
+    expect(info).toMatchObject({ size: 5 * 1024 * 1024 + 5, contentType: "text/plain" });
+    const object = await local.storage.get("uploads/big.txt");
+    expect((await new Response(object?.body).text()).endsWith("xworld")).toBe(true);
+
+    const aborted = await local.storage.createMultipartUpload("uploads/aborted.txt");
+    await local.storage.abortMultipartUpload("uploads/aborted.txt", aborted.uploadId);
+    expect(existsSync(join(local.directory, ".podokit", "multipart", aborted.uploadId))).toBe(false);
+  });
+
+  it("reads the idle multipart lifetime in seconds", () => {
+    expect(multipartMaxAgeMs(undefined)).toBe(24 * 60 * 60 * 1000);
+    expect(multipartMaxAgeMs("")).toBe(24 * 60 * 60 * 1000);
+    expect(multipartMaxAgeMs("3600")).toBe(3_600_000);
+    for (const value of ["0", "-1", "1.5", "a day"]) {
+      expect(() => multipartMaxAgeMs(value)).toThrow("LOCAL_STORAGE_MULTIPART_MAX_AGE");
+    }
+  });
+});
+
 describe("local download safety headers", () => {
   it("renders only script-free types inline", () => {
     expect(downloadSafetyHeaders("image/png")["content-disposition"]).toBe("inline");

package/dist/templates/modules/object-storage-local/files/apps/api/src/storage-local/storage-local.module.ts

@@ -27,6 +27,17 @@ import {
 } from "./storage-demo";
 
 export const DOWNLOAD_BASE_URL = "/files/content";
+const DEFAULT_MULTIPART_MAX_AGE_SECONDS = 24 * 60 * 60;
+
+/** How long an unfinished multipart upload may sit idle before its parts are removed. */
+export function multipartMaxAgeMs(value = process.env.LOCAL_STORAGE_MULTIPART_MAX_AGE): number {
+  if (value === undefined || value.trim() === "") return DEFAULT_MULTIPART_MAX_AGE_SECONDS * 1000;
+  const seconds = Number(value);
+  if (!Number.isInteger(seconds) || seconds < 1) {
+    throw new Error("LOCAL_STORAGE_MULTIPART_MAX_AGE must be a positive integer of seconds");
+  }
+  return seconds * 1000;
+}
 export const LOCAL_DOWNLOAD_URLS = Symbol("local-download-urls") as ServiceKey<DownloadUrlSigner>;
 
 async function readObject(storage: ObjectStore, key: string): Promise<ObjectData> {
@@ -124,7 +135,11 @@ export const storageLocalModule: PodokitModule = {
     const root = resolve(process.env.LOCAL_STORAGE_PATH ?? "./data/files");
     const signer = new DownloadUrlSigner(join(root, ".podokit", "download-url.key"));
     const storage = new SignedDownloadStore(
-      new LocalObjectStore({ rootDirectory: root, publicBaseUrl: DOWNLOAD_BASE_URL }),
+      new LocalObjectStore({
+        rootDirectory: root,
+        publicBaseUrl: DOWNLOAD_BASE_URL,
+        multipartMaxAgeMs: multipartMaxAgeMs(),
+      }),
       signer,
       DOWNLOAD_BASE_URL,
     );

package/dist/templates/modules/object-storage-local/module.manifest.json

@@ -16,7 +16,9 @@
   "targetApp": "api",
   "env": [
     "# Local object storage root. Use an absolute path in production and desktop packaging.",
-    "LOCAL_STORAGE_PATH=./data/files"
+    "LOCAL_STORAGE_PATH=./data/files",
+    "# Seconds an unfinished multipart upload may sit idle before its parts are removed.",
+    "LOCAL_STORAGE_MULTIPART_MAX_AGE=86400"
   ],
   "inject": [
     {
@@ -28,12 +30,19 @@
       "file": "apps/api/src/app.ts",
       "marker": "// podokit:end:modules",
       "text": "storageLocalModule,"
+    },
+    {
+      "file": "AGENTS.md",
+      "marker": "<!-- podokit:end:agents-modules -->",
+      "optional": true,
+      "text": "### object-storage-local\n- Store files through `OBJECT_STORAGE` from `@podosoft/podokit-runtime` (`services.resolve(OBJECT_STORAGE)`), not the provider directly. `put(key, body, { contentType })` streams a `ReadableStream` such as `request.body`, a `Blob` or file, an async iterable, bytes, or a string without buffering it; a failed body leaves no partial object.\n- For uploads split across requests (resumable or chunked), use `createMultipartUpload`, `uploadPart` (parts numbered 1 to 10,000, each but the last at least `MIN_MULTIPART_PART_BYTES` = 5 MiB), `completeMultipartUpload`, and `abortMultipartUpload`. Branch on `MultipartUploadError.code` (`UPLOAD_NOT_FOUND`, `INVALID_PART`, `PART_TOO_SMALL`).\n- Unfinished multipart uploads live under `LOCAL_STORAGE_PATH/.podokit/multipart/` and are removed after `LOCAL_STORAGE_MULTIPART_MAX_AGE` seconds without activity.\n"
     }
   ],
   "instructions": [
     "Local object storage is single-host. Back up LOCAL_STORAGE_PATH together with the database.",
     "Keep the API at one replica or select the S3 provider.",
     "Download URLs are signed and expire after one hour by default. The signing key lives in LOCAL_STORAGE_PATH/.podokit/download-url.key; deleting it invalidates every issued URL.",
-    "The /storage demo routes need the auth module and an administrator session, and only reach keys under demo/."
+    "The /storage demo routes need the auth module and an administrator session, and only reach keys under demo/.",
+    "Multipart upload parts live under LOCAL_STORAGE_PATH/.podokit/multipart until the upload completes or is aborted; uploads idle longer than LOCAL_STORAGE_MULTIPART_MAX_AGE seconds are removed."
   ]
 }

package/dist/templates/modules/object-storage-s3/files/apps/api/src/storage/s3-multipart.spec.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "bun:test";
+import { MultipartUploadError } from "@podosoft/podokit-runtime";
+import { S3Multipart, type S3Target } from "./s3-multipart";
+
+interface Call {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body: string | undefined;
+}
+
+function fakeS3(...responses: Response[]): { calls: Call[]; fetch: (input: string, init: RequestInit) => Promise<Response> } {
+  const calls: Call[] = [];
+  return {
+    calls,
+    fetch: async (input, init) => {
+      calls.push({
+        url: input,
+        method: init.method ?? "GET",
+        headers: init.headers as Record<string, string>,
+        body: init.body === undefined ? undefined : await new Response(init.body as BodyInit).text(),
+      });
+      const response = responses.shift();
+      if (!response) throw new Error("unexpected request");
+      return response;
+    },
+  };
+}
+
+function errorXml(code: string, status: number): Response {
+  return new Response(`<?xml version="1.0"?><Error><Code>${code}</Code><Message>${code} message</Message></Error>`, {
+    status,
+  });
+}
+
+const target: S3Target = {
+  bucket: "podokit",
+  region: "us-east-1",
+  endpoint: "http://localhost:9000",
+  virtualHostedStyle: false,
+  credentials: { accessKeyId: "podokit", secretAccessKey: "podokitsecret" },
+};
+
+describe("S3Multipart", () => {
+  it("creates, uploads, completes, and aborts with signed path-style requests", async () => {
+    const s3 = fakeS3(
+      new Response("<InitiateMultipartUploadResult><UploadId>id+1/2</UploadId></InitiateMultipartUploadResult>"),
+      new Response("", { headers: { etag: "\"abc\"" } }),
+      new Response("<CompleteMultipartUploadResult><ETag>&quot;x-1&quot;</ETag></CompleteMultipartUploadResult>"),
+      new Response(null, { status: 204 }),
+    );
+    const multipart = new S3Multipart(target, s3.fetch);
+
+    const uploadId = await multipart.create("videos/a b+c.mp4", "video/mp4");
+    expect(uploadId).toBe("id+1/2");
+    expect(await multipart.uploadPart("videos/a b+c.mp4", uploadId, 1, new TextEncoder().encode("part"))).toBe("\"abc\"");
+    await multipart.complete("videos/a b+c.mp4", uploadId, [{ partNumber: 1, etag: "\"abc\"" }]);
+    await multipart.abort("videos/a b+c.mp4", uploadId);
+
+    const object = "http://localhost:9000/podokit/videos/a%20b%2Bc.mp4";
+    expect(s3.calls.map((call) => [call.method, call.url])).toEqual([
+      ["POST", `${object}?uploads=`],
+      ["PUT", `${object}?partNumber=1&uploadId=id%2B1%2F2`],
+      ["POST", `${object}?uploadId=id%2B1%2F2`],
+      ["DELETE", `${object}?uploadId=id%2B1%2F2`],
+    ]);
+    expect(s3.calls[0]?.headers["content-type"]).toBe("video/mp4");
+    expect(s3.calls[1]?.headers["x-amz-content-sha256"]).toBe("UNSIGNED-PAYLOAD");
+    expect(s3.calls[1]?.body).toBe("part");
+    expect(s3.calls[2]?.body).toBe(
+      "<CompleteMultipartUpload><Part><PartNumber>1</PartNumber><ETag>&quot;abc&quot;</ETag></Part></CompleteMultipartUpload>",
+    );
+    for (const call of s3.calls) {
+      expect(call.headers.authorization).toStartWith("AWS4-HMAC-SHA256 Credential=podokit/");
+    }
+  });
+
+  it("addresses the bucket by host name in virtual-hosted style and on AWS by default", async () => {
+    const s3 = fakeS3(
+      new Response("<UploadId>one</UploadId>"),
+      new Response("<UploadId>two</UploadId>"),
+    );
+    await new S3Multipart({ ...target, virtualHostedStyle: true }, s3.fetch).create("a.txt");
+    const { endpoint: _endpoint, ...aws } = target;
+    await new S3Multipart({ ...aws, region: "eu-west-1", virtualHostedStyle: true }, s3.fetch).create("a.txt");
+    expect(s3.calls.map((call) => call.url)).toEqual([
+      "http://podokit.localhost:9000/a.txt?uploads=",
+      "https://podokit.s3.eu-west-1.amazonaws.com/a.txt?uploads=",
+    ]);
+  });
+
+  it("maps S3 error codes to multipart error codes", async () => {
+    const s3 = fakeS3(
+      errorXml("NoSuchUpload", 404),
+      errorXml("InvalidPart", 400),
+      // S3 may report a failed completion in a 200 response.
+      new Response("<Error><Code>EntityTooSmall</Code><Message>small</Message></Error>"),
+      errorXml("AccessDenied", 403),
+      errorXml("NoSuchUpload", 404),
+    );
+    const multipart = new S3Multipart(target, s3.fetch);
+    const codeOf = (error: unknown): string | undefined =>
+      error instanceof MultipartUploadError ? error.code : undefined;
+
+    expect(codeOf(await multipart.uploadPart("a", "x", 1, new Uint8Array(1)).catch((error: unknown) => error)))
+      .toBe("UPLOAD_NOT_FOUND");
+    expect(codeOf(await multipart.complete("a", "x", [{ partNumber: 1, etag: "e" }]).catch((error: unknown) => error)))
+      .toBe("INVALID_PART");
+    expect(codeOf(await multipart.complete("a", "x", [{ partNumber: 1, etag: "e" }]).catch((error: unknown) => error)))
+      .toBe("PART_TOO_SMALL");
+    await expect(multipart.create("a")).rejects.toThrow("AccessDenied");
+    // Aborting an upload that is already gone succeeds.
+    await multipart.abort("a", "x");
+  });
+});

package/dist/templates/modules/object-storage-s3/files/apps/api/src/storage/s3-multipart.ts

@@ -0,0 +1,171 @@
+import {
+  MultipartUploadError,
+  type CompletedPart,
+  type MultipartUploadErrorCode,
+} from "@podosoft/podokit-runtime";
+import {
+  EMPTY_PAYLOAD_HASH,
+  encodeRfc3986,
+  signS3Request,
+  UNSIGNED_PAYLOAD,
+  type S3Credentials,
+} from "./s3-signer";
+
+export interface S3Target {
+  bucket: string;
+  region: string;
+  /** Defaults to the AWS regional endpoint. */
+  endpoint?: string;
+  virtualHostedStyle: boolean;
+  credentials: S3Credentials;
+}
+
+type FetchLike = (input: string, init: RequestInit) => Promise<Response>;
+
+const ERROR_CODES: Record<string, MultipartUploadErrorCode> = {
+  NoSuchUpload: "UPLOAD_NOT_FOUND",
+  InvalidPart: "INVALID_PART",
+  InvalidPartOrder: "INVALID_PART",
+  EntityTooSmall: "PART_TOO_SMALL",
+};
+
+function xmlValue(xml: string, element: string): string | undefined {
+  const match = new RegExp(`<${element}>([^<]*)</${element}>`).exec(xml);
+  return match?.[1]
+    ?.replaceAll("&quot;", "\"")
+    .replaceAll("&apos;", "'")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">")
+    .replaceAll("&amp;", "&");
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll("\"", "&quot;")
+    .replaceAll("'", "&apos;");
+}
+
+function s3Error(operation: string, status: number, xml: string): Error {
+  const code = xmlValue(xml, "Code");
+  const message = xmlValue(xml, "Message") ?? `status ${status}`;
+  const mapped = code ? ERROR_CODES[code] : undefined;
+  if (mapped) return new MultipartUploadError(mapped, `${operation} failed: ${message}`);
+  return new Error(`${operation} failed with ${code ?? `status ${status}`}: ${message}`);
+}
+
+/**
+ * S3 multipart operations over signed requests: create, upload part, complete,
+ * and abort. Works with AWS S3 and MinIO-compatible services such as Silo.
+ */
+export class S3Multipart {
+  private readonly base: URL;
+
+  constructor(
+    private readonly target: S3Target,
+    private readonly fetchImpl: FetchLike = fetch,
+  ) {
+    this.base = new URL(target.endpoint ?? `https://s3.${target.region}.amazonaws.com`);
+  }
+
+  async create(key: string, contentType?: string): Promise<string> {
+    const response = await this.send("POST", key, [["uploads", ""]], {
+      ...(contentType ? { "content-type": contentType } : {}),
+    });
+    const xml = await response.text();
+    if (!response.ok) throw s3Error("CreateMultipartUpload", response.status, xml);
+    const uploadId = xmlValue(xml, "UploadId");
+    if (!uploadId) throw new Error("CreateMultipartUpload returned no upload id");
+    return uploadId;
+  }
+
+  /** Returns the part's entity tag. The body's length must be known, as S3 requires. */
+  async uploadPart(key: string, uploadId: string, partNumber: number, body: Uint8Array | Blob): Promise<string> {
+    const response = await this.send(
+      "PUT",
+      key,
+      [["partNumber", String(partNumber)], ["uploadId", uploadId]],
+      {},
+      body,
+    );
+    const xml = await response.text();
+    if (!response.ok) throw s3Error("UploadPart", response.status, xml);
+    const etag = response.headers.get("etag");
+    if (!etag) throw new Error("UploadPart returned no entity tag");
+    return etag;
+  }
+
+  async complete(key: string, uploadId: string, parts: readonly CompletedPart[]): Promise<void> {
+    const document = [
+      "<CompleteMultipartUpload>",
+      ...parts.map((part) =>
+        `<Part><PartNumber>${part.partNumber}</PartNumber><ETag>${escapeXml(part.etag)}</ETag></Part>`
+      ),
+      "</CompleteMultipartUpload>",
+    ].join("");
+    const response = await this.send(
+      "POST",
+      key,
+      [["uploadId", uploadId]],
+      { "content-type": "application/xml" },
+      new TextEncoder().encode(document),
+    );
+    const xml = await response.text();
+    // S3 can report a failed completion inside a 200 response.
+    if (!response.ok || xml.includes("<Error>")) {
+      throw s3Error("CompleteMultipartUpload", response.status, xml);
+    }
+  }
+
+  /** Resolves when the upload no longer exists, including when it never did. */
+  async abort(key: string, uploadId: string): Promise<void> {
+    const response = await this.send("DELETE", key, [["uploadId", uploadId]]);
+    const xml = await response.text();
+    if (response.ok) return;
+    const error = s3Error("AbortMultipartUpload", response.status, xml);
+    if (error instanceof MultipartUploadError && error.code === "UPLOAD_NOT_FOUND") return;
+    throw error;
+  }
+
+  private objectUrl(key: string): URL {
+    const url = new URL(this.base.href);
+    const basePath = url.pathname.replace(/\/$/, "");
+    const encodedKey = key.split("/").map(encodeRfc3986).join("/");
+    if (this.target.virtualHostedStyle) {
+      url.hostname = `${this.target.bucket}.${url.hostname}`;
+      url.pathname = `${basePath}/${encodedKey}`;
+    } else {
+      url.pathname = `${basePath}/${encodeRfc3986(this.target.bucket)}/${encodedKey}`;
+    }
+    return url;
+  }
+
+  private send(
+    method: string,
+    key: string,
+    query: ReadonlyArray<readonly [string, string]>,
+    headers: Record<string, string> = {},
+    body?: Uint8Array | Blob,
+  ): Promise<Response> {
+    const signed = signS3Request(
+      {
+        method,
+        url: this.objectUrl(key),
+        query,
+        headers,
+        // Payloads are sent unsigned so a part never has to be hashed before it is sent.
+        payloadHash: body === undefined ? EMPTY_PAYLOAD_HASH : UNSIGNED_PAYLOAD,
+      },
+      this.target.credentials,
+      this.target.region,
+    );
+    return this.fetchImpl(signed.url, {
+      method,
+      headers: signed.headers,
+      // Bytes on a SharedArrayBuffer are not a BodyInit in lib.dom; S3 parts never are.
+      ...(body === undefined ? {} : { body: body as BodyInit }),
+    });
+  }
+}