@prisma/compute-sdk 0.19.0 → 0.21.0

package/dist/upload-artifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-artifact.d.ts","sourceRoot":"","sources":["../src/upload-artifact.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAsB,cAAc,CAClC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,UAAU,EAChB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC,CAsBf"}

package/dist/upload-artifact.js

@@ -0,0 +1,27 @@
+/**
+ * PUT a gzipped compute artifact to a Foundry-minted presigned upload URL.
+ */
+export async function uploadArtifact(uploadUrl, body, signal) {
+    signal?.throwIfAborted();
+    // Intentionally do not pass AbortSignal to this mutating upload request.
+    // Aborting transport can leave completion ambiguous server-side.
+    const response = await fetch(uploadUrl, {
+        method: "PUT",
+        headers: { "content-type": "application/gzip" },
+        body,
+    });
+    if (!response.ok) {
+        let message = `Artifact upload failed with HTTP ${response.status}`;
+        try {
+            const json = (await response.json());
+            if (typeof json.error === "string" && json.error.length > 0) {
+                message = `Artifact upload failed: ${json.error}`;
+            }
+        }
+        catch {
+            // ignore body parse failures
+        }
+        throw new Error(message);
+    }
+}
+//# sourceMappingURL=upload-artifact.js.map

package/dist/upload-artifact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-artifact.js","sourceRoot":"","sources":["../src/upload-artifact.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,SAAiB,EACjB,IAAgB,EAChB,MAAoB;IAEpB,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,yEAAyE;IACzE,iEAAiE;IACjE,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,SAAS,EAAE;QACtC,MAAM,EAAE,KAAK;QACb,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;QAC/C,IAAI;KACL,CAAC,CAAC;IAEH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;QACjB,IAAI,OAAO,GAAG,oCAAoC,QAAQ,CAAC,MAAM,EAAE,CAAC;QACpE,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAwB,CAAC;YAC5D,IAAI,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC5D,OAAO,GAAG,2BAA2B,IAAI,CAAC,KAAK,EAAE,CAAC;YACpD,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,6BAA6B;QAC/B,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/compute-sdk",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "TypeScript SDK for deploying and managing applications on Prisma Compute",
   "license": "Apache-2.0",
   "repository": "prisma/project-compute",

package/src/api-client.ts

@@ -31,10 +31,12 @@ export class InternalApiClient {
   }
 
   async createProject(body: CreateProjectBody, signal?: AbortSignal) {
+    signal?.throwIfAborted();
     return this.#request(
       this.#client.POST("/v1/projects", {
         body: body as SdkCreateProjectBody,
-        signal,
+        // Intentionally do not pass AbortSignal for mutating operations.
+        // Aborting transport can leave remote completion ambiguous.
       }),
       "/v1/projects",
       signal,
@@ -69,11 +71,13 @@ export class InternalApiClient {
     body: CreateProjectServiceBody,
     signal?: AbortSignal,
   ) {
+    signal?.throwIfAborted();
     return this.#request(
       this.#client.POST("/v1/projects/{projectId}/compute-services", {
         params: { path: { projectId } },
         body: body as SdkCreateProjectServiceBody,
-        signal,
+        // Intentionally do not pass AbortSignal for mutating operations.
+        // Aborting transport can leave remote completion ambiguous.
       }),
       "/v1/projects/{projectId}/compute-services",
       signal,
@@ -95,10 +99,12 @@ export class InternalApiClient {
     computeServiceId: string,
     signal?: AbortSignal,
   ): Promise<Result<void, ApiClientError>> {
+    signal?.throwIfAborted();
     return this.#unwrapVoid(
       this.#client.DELETE("/v1/compute-services/{computeServiceId}", {
         params: { path: { computeServiceId } },
-        signal,
+        // Intentionally do not pass AbortSignal for mutating operations.
+        // Aborting transport can leave remote completion ambiguous.
       }),
       signal,
     );
@@ -124,11 +130,13 @@ export class InternalApiClient {
     body?: CreateServiceVersionBody,
     signal?: AbortSignal,
   ) {
+    signal?.throwIfAborted();
     return this.#request(
       this.#client.POST("/v1/compute-services/{computeServiceId}/versions", {
         params: { path: { computeServiceId } },
         body,
-        signal,
+        // Intentionally do not pass AbortSignal for mutating operations.
+        // Aborting transport can leave remote completion ambiguous.
       }),
       "/v1/compute-services/{computeServiceId}/versions",
       signal,
@@ -147,10 +155,12 @@ export class InternalApiClient {
   }
 
   async startVersion(versionId: string, signal?: AbortSignal) {
+    signal?.throwIfAborted();
     return this.#request(
       this.#client.POST("/v1/compute-services/versions/{versionId}/start", {
         params: { path: { versionId } },
-        signal,
+        // Intentionally do not pass AbortSignal for mutating operations.
+        // Aborting transport can leave remote completion ambiguous.
       }),
       "/v1/compute-services/versions/{versionId}/start",
       signal,
@@ -161,10 +171,12 @@ export class InternalApiClient {
     versionId: string,
     signal?: AbortSignal,
   ): Promise<Result<void, ApiClientError>> {
+    signal?.throwIfAborted();
     return this.#unwrapVoid(
       this.#client.POST("/v1/compute-services/versions/{versionId}/stop", {
         params: { path: { versionId } },
-        signal,
+        // Intentionally do not pass AbortSignal for mutating operations.
+        // Aborting transport can leave remote completion ambiguous.
       }),
       signal,
     );
@@ -174,10 +186,12 @@ export class InternalApiClient {
     versionId: string,
     signal?: AbortSignal,
   ): Promise<Result<void, ApiClientError>> {
+    signal?.throwIfAborted();
     return this.#unwrapVoid(
       this.#client.DELETE("/v1/compute-services/versions/{versionId}", {
         params: { path: { versionId } },
-        signal,
+        // Intentionally do not pass AbortSignal for mutating operations.
+        // Aborting transport can leave remote completion ambiguous.
       }),
       signal,
     );
@@ -188,11 +202,13 @@ export class InternalApiClient {
     body: PromoteServiceBody,
     signal?: AbortSignal,
   ) {
+    signal?.throwIfAborted();
     return this.#request(
       this.#client.POST("/v1/compute-services/{computeServiceId}/promote", {
         params: { path: { computeServiceId } },
         body,
-        signal,
+        // Intentionally do not pass AbortSignal for mutating operations.
+        // Aborting transport can leave remote completion ambiguous.
       }),
       "/v1/compute-services/{computeServiceId}/promote",
       signal,

package/src/archive.ts

@@ -17,12 +17,14 @@ const COMPUTE_MANIFEST_VERSION = "1" as const;
 export async function createArchive(
   directory: string,
   entrypoint: string,
+  signal?: AbortSignal,
 ): Promise<Uint8Array> {
+  signal?.throwIfAborted();
   const packer = pack();
   const rootPath = path.resolve(directory);
 
   // Walk the directory and add all files
-  await addDirectory(packer, rootPath, rootPath, "bundle");
+  await addDirectory(packer, rootPath, rootPath, "bundle", signal);
 
   // Inject the manifest as a synthetic entry
   const manifest = JSON.stringify(
@@ -39,7 +41,7 @@ export async function createArchive(
   packer.finalize();
 
   // Pipe through gzip and collect into buffer
-  return await collectGzipped(packer);
+  return await collectGzipped(packer, signal);
 }
 
 async function addDirectory(
@@ -47,22 +49,25 @@ async function addDirectory(
   rootPath: string,
   fsPath: string,
   tarPrefix: string,
+  signal?: AbortSignal,
 ): Promise<void> {
+  signal?.throwIfAborted();
   const directoryPath = resolvePathWithinRoot(rootPath, fsPath);
   const entries = await readdir(directoryPath, { withFileTypes: true });
 
   for (const entry of entries) {
+    signal?.throwIfAborted();
     const fullPath = path.join(directoryPath, entry.name);
     const tarPath = `${tarPrefix}/${entry.name}`;
 
     if (entry.isSymbolicLink()) {
       const linkStat = await lstat(fullPath);
-      await addSymlink(packer, rootPath, fullPath, tarPath, linkStat);
+      await addSymlink(packer, rootPath, fullPath, tarPath, linkStat, signal);
     } else if (entry.isDirectory()) {
-      await addDirectory(packer, rootPath, fullPath, tarPath);
+      await addDirectory(packer, rootPath, fullPath, tarPath, signal);
     } else if (entry.isFile()) {
       const fileStat = await lstat(fullPath);
-      await addFile(packer, rootPath, fullPath, tarPath, fileStat);
+      await addFile(packer, rootPath, fullPath, tarPath, fileStat, signal);
     }
   }
 }
@@ -73,7 +78,9 @@ async function addFile(
   fsPath: string,
   tarPath: string,
   fileStat: { size: number; mode: number; mtime: Date },
+  signal?: AbortSignal,
 ): Promise<void> {
+  signal?.throwIfAborted();
   const filePath = resolvePathWithinRoot(rootPath, fsPath);
   const content = await readFile(filePath);
   packer.entry(
@@ -93,13 +100,16 @@ async function addSymlink(
   fsPath: string,
   tarPath: string,
   linkStat: { mode: number; mtime: Date },
+  signal?: AbortSignal,
 ): Promise<void> {
+  signal?.throwIfAborted();
   const symlinkPath = resolvePathWithinRoot(rootPath, fsPath);
   const target = await readlink(symlinkPath);
   const linkname = await resolveArchiveSymlinkTarget(
     rootPath,
     symlinkPath,
     target,
+    signal,
   );
 
   packer.entry({
@@ -115,7 +125,9 @@ async function resolveArchiveSymlinkTarget(
   rootPath: string,
   symlinkPath: string,
   target: string,
+  signal?: AbortSignal,
 ): Promise<string> {
+  signal?.throwIfAborted();
   const symlinkDir = path.dirname(symlinkPath);
   const resolvedTarget = resolvePathWithinRoot(
     rootPath,
@@ -163,11 +175,27 @@ function resolvePathWithinRoot(rootPath: string, fsPath: string): string {
   return resolvedPath;
 }
 
-function collectGzipped(packer: Pack): Promise<Uint8Array> {
-  return new Promise<Uint8Array>((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    const gzip = createGzip();
-
+function collectGzipped(
+  packer: Pack,
+  signal?: AbortSignal,
+): Promise<Uint8Array> {
+  signal?.throwIfAborted();
+
+  const chunks: Buffer[] = [];
+  const gzip = createGzip();
+  const onAbort = () => {
+    // AbortSignal.abort() sets signal.reason; fallback keeps a stream error path if a non-standard signal omits it.
+    const abortError =
+      signal?.reason instanceof Error
+        ? signal.reason
+        : new DOMException("The operation was aborted", "AbortError");
+    gzip.destroy(abortError);
+    packer.destroy(abortError);
+  };
+
+  signal?.addEventListener("abort", onAbort, { once: true });
+
+  const promise = new Promise<Uint8Array>((resolve, reject) => {
     packer.pipe(gzip);
 
     gzip.on("data", (chunk: Buffer) => {
@@ -181,4 +209,8 @@ function collectGzipped(packer: Pack): Promise<Uint8Array> {
     gzip.on("error", reject);
     packer.on("error", reject);
   });
+
+  return promise.finally(() => {
+    signal?.removeEventListener("abort", onAbort);
+  });
 }

package/src/artifact-postprocess.ts

@@ -0,0 +1,74 @@
+import { cp, readdir, readlink, realpath, rm, stat } from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * Materialize symlinks inside a build artifact that point outside the artifact
+ * directory but still live under the original app tree (typical for Next.js
+ * standalone output referencing monorepo node_modules).
+ */
+export async function normalizeArtifactSymlinks(
+  artifactDir: string,
+  appPath: string,
+  signal?: AbortSignal,
+): Promise<void> {
+  signal?.throwIfAborted();
+  const normalizedArtifactDir = await realpath(path.resolve(artifactDir));
+  const normalizedAppPath = await realpath(path.resolve(appPath));
+
+  await walkDirectory(path.resolve(artifactDir));
+
+  async function walkDirectory(directory: string): Promise<void> {
+    signal?.throwIfAborted();
+    const entries = await readdir(directory, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(directory, entry.name);
+
+      if (entry.isDirectory()) {
+        await walkDirectory(fullPath);
+        continue;
+      }
+
+      if (!entry.isSymbolicLink()) {
+        continue;
+      }
+
+      const target = await readlink(fullPath);
+      const resolvedTarget = path.resolve(path.dirname(fullPath), target);
+      const realTarget = await realpath(resolvedTarget);
+
+      if (isPathWithin(normalizedArtifactDir, realTarget)) {
+        continue;
+      }
+
+      if (!isPathWithin(normalizedAppPath, realTarget)) {
+        throw new Error(
+          `Build artifact symlink escapes the app directory: ${realTarget}`,
+        );
+      }
+
+      const targetStat = await stat(realTarget);
+      await rm(fullPath, { force: true, recursive: true });
+      await cp(realTarget, fullPath, {
+        recursive: targetStat.isDirectory(),
+        // Keep nested symlinks intact so walkDirectory can validate each one.
+        dereference: false,
+      });
+
+      if (targetStat.isDirectory()) {
+        await walkDirectory(fullPath);
+      }
+    }
+  }
+}
+
+function isPathWithin(rootPath: string, candidatePath: string): boolean {
+  const relativePath = path.relative(rootPath, candidatePath);
+
+  return (
+    relativePath === "" ||
+    (!relativePath.startsWith(`..${path.sep}`) &&
+      relativePath !== ".." &&
+      !path.isAbsolute(relativePath))
+  );
+}

package/src/astro-build.ts

@@ -27,14 +27,15 @@ export class AstroBuild implements BuildStrategy {
     this.#appPath = options.appPath;
   }
 
-  async canBuild(): Promise<boolean> {
+  async canBuild(signal?: AbortSignal): Promise<boolean> {
     return (
-      (await hasRootFile(this.#appPath, ASTRO_CONFIG_FILENAMES)) ||
-      (await hasPackageDependency(this.#appPath, ["astro"]))
+      (await hasRootFile(this.#appPath, ASTRO_CONFIG_FILENAMES, signal)) ||
+      (await hasPackageDependency(this.#appPath, ["astro"], signal))
     );
   }
 
-  async execute(): Promise<BuildArtifact> {
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
     await runPackageCli({
       appPath: this.#appPath,
       cliName: "astro",
@@ -42,6 +43,7 @@ export class AstroBuild implements BuildStrategy {
       failurePrefix: "Astro",
       missingMessage:
         "Could not find the Astro CLI. Install it with `npm install astro` or ensure npx/bunx is available.",
+      signal,
     });
 
     const distDir = path.join(this.#appPath, "dist");

package/src/auto-build.ts

@@ -25,19 +25,21 @@ export class AutoBuild implements BuildStrategy {
     ];
   }
 
-  async canBuild(): Promise<boolean> {
+  async canBuild(signal?: AbortSignal): Promise<boolean> {
     for (const strategy of this.#strategies) {
-      if (await strategy.canBuild()) {
+      signal?.throwIfAborted();
+      if (await strategy.canBuild(signal)) {
         return true;
       }
     }
     return false;
   }
 
-  async execute(): Promise<BuildArtifact> {
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
     for (const strategy of this.#strategies) {
-      if (await strategy.canBuild()) {
-        return strategy.execute();
+      signal?.throwIfAborted();
+      if (await strategy.canBuild(signal)) {
+        return strategy.execute(signal);
       }
     }
     throw new Error("No suitable build strategy found for this application");

package/src/build-strategy.ts

@@ -32,8 +32,8 @@ export interface BuildArtifact {
  * A build strategy produces a deployable artifact.
  */
 export interface BuildStrategy {
-  canBuild(): Promise<boolean>;
-  execute(): Promise<BuildArtifact>;
+  canBuild(signal?: AbortSignal): Promise<boolean>;
+  execute(signal?: AbortSignal): Promise<BuildArtifact>;
 }
 
 /**
@@ -49,11 +49,12 @@ export class PreBuilt implements BuildStrategy {
     this.#entrypoint = options.entrypoint;
   }
 
-  async canBuild(): Promise<boolean> {
+  async canBuild(_signal?: AbortSignal): Promise<boolean> {
     return true;
   }
 
-  async execute(): Promise<BuildArtifact> {
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
     const normalized = path.normalize(this.#entrypoint);
 
     if (path.isAbsolute(normalized)) {
@@ -92,7 +93,9 @@ export class PreBuilt implements BuildStrategy {
 export async function hasRootFile(
   appPath: string,
   filenames: readonly string[],
+  signal?: AbortSignal,
 ): Promise<boolean> {
+  signal?.throwIfAborted();
   let entries: string[];
   try {
     entries = await readdir(appPath);
@@ -110,7 +113,9 @@ export async function hasRootFile(
 export async function hasPackageDependency(
   appPath: string,
   packageNames: readonly string[],
+  signal?: AbortSignal,
 ): Promise<boolean> {
+  signal?.throwIfAborted();
   let content: string;
   try {
     content = await readFile(path.join(appPath, "package.json"), "utf-8");
@@ -154,6 +159,7 @@ export async function runPackageCli(opts: {
   failurePrefix: string;
   /** Thrown when no launcher is available. */
   missingMessage: string;
+  signal?: AbortSignal;
 }): Promise<void> {
   const localBin = path.join(
     opts.appPath,
@@ -168,8 +174,9 @@ export async function runPackageCli(opts: {
   ];
 
   for (const { command, args } of candidates) {
+    opts.signal?.throwIfAborted();
     try {
-      await exec(command, args, opts.appPath, opts.failurePrefix);
+      await exec(command, args, opts.appPath, opts.failurePrefix, opts.signal);
       return;
     } catch (error) {
       if (isENOENT(error)) continue;
@@ -197,9 +204,10 @@ function exec(
   args: string[],
   cwd: string,
   failurePrefix: string,
+  signal?: AbortSignal,
 ): Promise<void> {
   return new Promise((resolve, reject) => {
-    execFile(command, args, { cwd }, (error, _stdout, stderr) => {
+    execFile(command, args, { cwd, signal }, (error, _stdout, stderr) => {
       if (error) {
         if ("code" in error && error.code === "ENOENT") {
           reject(

package/src/bun-build.ts

@@ -24,12 +24,13 @@ export class BunBuild implements BuildStrategy {
     this.#entrypoint = options.entrypoint;
   }
 
-  async canBuild(): Promise<boolean> {
+  async canBuild(_signal?: AbortSignal): Promise<boolean> {
     return true;
   }
 
-  async execute(): Promise<BuildArtifact> {
-    const entrypoint = await this.#resolveEntrypoint();
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
+    const entrypoint = await this.#resolveEntrypoint(signal);
 
     const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
     const bundleDir = path.join(outDir, "bundle");
@@ -38,7 +39,7 @@ export class BunBuild implements BuildStrategy {
     const absoluteEntrypoint = path.join(this.#appPath, entrypoint);
 
     try {
-      await this.#runBuild(absoluteEntrypoint, bundleDir);
+      await this.#runBuild(absoluteEntrypoint, bundleDir, signal);
     } catch (error) {
       await rm(outDir, { recursive: true, force: true });
       throw error;
@@ -62,7 +63,8 @@ export class BunBuild implements BuildStrategy {
     };
   }
 
-  async #resolveEntrypoint(): Promise<string> {
+  async #resolveEntrypoint(signal?: AbortSignal): Promise<string> {
+    signal?.throwIfAborted();
     const candidate = this.#entrypoint ?? (await this.#readPackageJsonMain());
 
     if (!candidate) {
@@ -125,7 +127,11 @@ export class BunBuild implements BuildStrategy {
     return typeof parsed.main === "string" ? parsed.main : undefined;
   }
 
-  #runBuild(absoluteEntrypoint: string, bundleDir: string): Promise<void> {
+  #runBuild(
+    absoluteEntrypoint: string,
+    bundleDir: string,
+    signal?: AbortSignal,
+  ): Promise<void> {
     return new Promise((resolve, reject) => {
       execFile(
         "bun",
@@ -138,6 +144,7 @@ export class BunBuild implements BuildStrategy {
           "bun",
           "--sourcemap=external",
         ],
+        { signal },
         (error, _stdout, stderr) => {
           if (error) {
             if ("code" in error && error.code === "ENOENT") {

package/src/compute-client.ts

@@ -48,6 +48,7 @@ import type {
   VersionInfo,
 } from "./types.ts";
 import { REGIONS } from "./types.ts";
+import { uploadArtifact } from "./upload-artifact.ts";
 
 type VersionDetailData = InferOk<
   Awaited<ReturnType<InternalApiClient["getVersion"]>>
@@ -243,7 +244,7 @@ export class ComputeClient {
       options.progress?.onBuildStart?.();
       const artifact = yield* Result.await(
         Result.tryPromise({
-          try: () => options.strategy.execute(),
+          try: () => options.strategy.execute(options.signal),
           catch: (e) =>
             new BuildError({
               message: e instanceof Error ? e.message : String(e),
@@ -258,7 +259,12 @@ export class ComputeClient {
         options.progress?.onArchiveCreating?.();
         const archiveBytes = yield* Result.await(
           Result.tryPromise({
-            try: () => createArchive(artifact.directory, artifact.entrypoint),
+            try: () =>
+              createArchive(
+                artifact.directory,
+                artifact.entrypoint,
+                options.signal,
+              ),
             catch: (e) =>
               new ArtifactError({
                 message:
@@ -304,7 +310,7 @@ export class ComputeClient {
 
         options.progress?.onUploadStart?.();
         yield* Result.await(
-          self.#uploadArtifact(uploadUrl, archiveBytes, options.signal),
+          self.#uploadArtifactResult(uploadUrl, archiveBytes, options.signal),
         );
         options.progress?.onUploadComplete?.();
 
@@ -1152,10 +1158,12 @@ export class ComputeClient {
   }
 
   #checkAborted(signal?: AbortSignal): Result<void, CancelledError> {
-    if (signal?.aborted) {
+    try {
+      signal?.throwIfAborted();
+      return Result.ok(undefined);
+    } catch {
       return Result.err(new CancelledError());
     }
-    return Result.ok(undefined);
   }
 
   async #resolveDeployTarget(options: {
@@ -1304,40 +1312,22 @@ export class ComputeClient {
     });
   }
 
-  async #uploadArtifact(
+  async #uploadArtifactResult(
     url: string,
     body: Uint8Array,
     signal?: AbortSignal,
   ): Promise<Result<void, ArtifactError | CancelledError>> {
     return Result.tryPromise({
       try: async () => {
-        const res = await fetch(url, {
-          method: "PUT",
-          headers: { "content-type": "application/gzip" },
-          body,
-          signal,
+        await uploadArtifact(url, body, signal);
+      },
+      catch: (e) => {
+        if (signal?.aborted) return new CancelledError();
+        return new ArtifactError({
+          message: e instanceof Error ? e.message : String(e),
+          cause: e,
         });
-
-        if (!res.ok) {
-          let message = `Artifact upload failed with HTTP ${res.status}`;
-          try {
-            const json = (await res.json()) as { error?: unknown };
-            if (typeof json.error === "string" && json.error.length > 0) {
-              message = `Artifact upload failed: ${json.error}`;
-            }
-          } catch {
-            // ignore body parse failures
-          }
-          throw new Error(message);
-        }
       },
-      catch: (e) =>
-        signal?.aborted
-          ? new CancelledError()
-          : new ArtifactError({
-              message: e instanceof Error ? e.message : String(e),
-              cause: e,
-            }),
     });
   }
 }

package/src/index.ts

@@ -7,6 +7,8 @@ export {
   type Result,
   TaggedError,
 } from "better-result";
+export { createArchive } from "./archive.ts";
+export { normalizeArtifactSymlinks } from "./artifact-postprocess.ts";
 export { AstroBuild } from "./astro-build.ts";
 export { AutoBuild } from "./auto-build.ts";
 export type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
@@ -94,3 +96,4 @@ export type {
   VersionInfo,
 } from "./types.ts";
 export { KNOWN_REGION_IDS, REGIONS } from "./types.ts";
+export { uploadArtifact } from "./upload-artifact.ts";