@prisma/compute-sdk 0.18.0 → 0.20.0

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/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

@@ -243,7 +243,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 +258,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:
@@ -1152,10 +1157,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: {
@@ -1311,11 +1318,13 @@ export class ComputeClient {
   ): Promise<Result<void, ArtifactError | CancelledError>> {
     return Result.tryPromise({
       try: async () => {
+        signal?.throwIfAborted();
+        // Intentionally do not pass AbortSignal to this mutating upload request.
+        // Aborting transport can leave completion ambiguous server-side.
         const res = await fetch(url, {
           method: "PUT",
           headers: { "content-type": "application/gzip" },
           body,
-          signal,
         });
 
         if (!res.ok) {
@@ -1331,13 +1340,13 @@ export class ComputeClient {
           throw new Error(message);
         }
       },
-      catch: (e) =>
-        signal?.aborted
-          ? new CancelledError()
-          : new ArtifactError({
-              message: e instanceof Error ? e.message : String(e),
-              cause: e,
-            }),
+      catch: (e) => {
+        if (signal?.aborted) return new CancelledError();
+        return new ArtifactError({
+          message: e instanceof Error ? e.message : String(e),
+          cause: e,
+        });
+      },
     });
   }
 }

package/src/nextjs-build.ts

@@ -1,4 +1,4 @@
-import { cp, mkdtemp, rm, stat } from "node:fs/promises";
+import { cp, mkdtemp, readdir, rm, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
@@ -26,14 +26,15 @@ export class NextjsBuild implements BuildStrategy {
     this.#appPath = options.appPath;
   }
 
-  async canBuild(): Promise<boolean> {
+  async canBuild(signal?: AbortSignal): Promise<boolean> {
     return (
-      (await hasRootFile(this.#appPath, NEXT_CONFIG_FILENAMES)) ||
-      (await hasPackageDependency(this.#appPath, ["next"]))
+      (await hasRootFile(this.#appPath, NEXT_CONFIG_FILENAMES, signal)) ||
+      (await hasPackageDependency(this.#appPath, ["next"], signal))
     );
   }
 
-  async execute(): Promise<BuildArtifact> {
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
     await runPackageCli({
       appPath: this.#appPath,
       cliName: "next",
@@ -41,6 +42,7 @@ export class NextjsBuild implements BuildStrategy {
       failurePrefix: "Next.js",
       missingMessage:
         "Could not find the Next.js CLI. Install it with `npm install next` or ensure npx/bunx is available.",
+      signal,
     });
 
     const standaloneDir = path.join(this.#appPath, ".next", "standalone");
@@ -61,9 +63,20 @@ export class NextjsBuild implements BuildStrategy {
         verbatimSymlinks: true,
       });
 
+      // In monorepos, Next preserves the workspace-relative path from the
+      // workspace root down to the app, so server.js lands at e.g.
+      // .next/standalone/apps/web/server.js, not at the standalone root.
+      // The runtime needs the correct entrypoint, and Next expects public/
+      // and .next/static/ to be siblings of server.js.
+      const serverSubpath = await findServerSubpath(artifactDir);
+      const serverDir =
+        serverSubpath === undefined
+          ? artifactDir
+          : path.join(artifactDir, serverSubpath);
+
       const publicDir = path.join(this.#appPath, "public");
       if (await directoryExists(publicDir)) {
-        await cp(publicDir, path.join(artifactDir, "public"), {
+        await cp(publicDir, path.join(serverDir, "public"), {
           recursive: true,
           verbatimSymlinks: true,
         });
@@ -71,15 +84,20 @@ export class NextjsBuild implements BuildStrategy {
 
       const staticDir = path.join(this.#appPath, ".next", "static");
       if (await directoryExists(staticDir)) {
-        await cp(staticDir, path.join(artifactDir, ".next", "static"), {
+        await cp(staticDir, path.join(serverDir, ".next", "static"), {
           recursive: true,
           verbatimSymlinks: true,
         });
       }
 
+      const entrypoint =
+        serverSubpath === undefined
+          ? "server.js"
+          : path.posix.join(serverSubpath, "server.js");
+
       return {
         directory: artifactDir,
-        entrypoint: "server.js",
+        entrypoint,
         defaultPortMapping: { http: 3000 },
         cleanup: () => rm(outDir, { recursive: true, force: true }),
       };
@@ -94,3 +112,51 @@ async function directoryExists(dirPath: string): Promise<boolean> {
   const s = await stat(dirPath).catch(() => null);
   return s?.isDirectory() ?? false;
 }
+
+/**
+ * Scan the Next.js standalone output to find the directory that contains
+ * server.js, relative to the standalone root. Returns undefined when
+ * server.js is at the root (single-app repos) and a posix-joined subpath
+ * like "apps/web" for monorepos. node_modules is skipped because
+ * third-party packages may ship a file named server.js.
+ */
+async function findServerSubpath(
+  standaloneDir: string,
+): Promise<string | undefined> {
+  const matches: (string | undefined)[] = [];
+
+  async function walk(
+    currentDir: string,
+    relative: string | undefined,
+  ): Promise<void> {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === "node_modules") continue;
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        const nextRelative =
+          relative === undefined
+            ? entry.name
+            : path.posix.join(relative, entry.name);
+        await walk(fullPath, nextRelative);
+      } else if (entry.isFile() && entry.name === "server.js") {
+        matches.push(relative);
+      }
+    }
+  }
+
+  await walk(standaloneDir, undefined);
+
+  if (matches.length > 1) {
+    const locations = matches.map((m) => m ?? "<root>").join(", ");
+    throw new Error(
+      `Next.js standalone output has multiple server.js files (${locations}). Cannot determine the application entrypoint.`,
+    );
+  }
+  if (matches.length === 0) {
+    throw new Error(
+      "Next.js standalone output is missing server.js. The build may not have completed successfully.",
+    );
+  }
+  return matches[0];
+}

package/src/nuxt-build.ts

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

package/src/tanstack-start-build.ts

@@ -20,11 +20,12 @@ export class TanstackStartBuild implements BuildStrategy {
     this.#appPath = options.appPath;
   }
 
-  async canBuild(): Promise<boolean> {
-    return hasPackageDependency(this.#appPath, TANSTACK_START_PACKAGES);
+  async canBuild(signal?: AbortSignal): Promise<boolean> {
+    return hasPackageDependency(this.#appPath, TANSTACK_START_PACKAGES, signal);
   }
 
-  async execute(): Promise<BuildArtifact> {
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
     await runPackageCli({
       appPath: this.#appPath,
       cliName: "vite",
@@ -32,6 +33,7 @@ export class TanstackStartBuild implements BuildStrategy {
       failurePrefix: "TanStack Start",
       missingMessage:
         "Could not find the Vite CLI. Install it with `npm install vite` or ensure npx/bunx is available.",
+      signal,
     });
 
     const outputDir = path.join(this.#appPath, ".output");