@prisma/compute-sdk 0.28.0 → 0.30.0

package/src/compute-client.ts

@@ -11,9 +11,9 @@ import type { BuildStrategy } from "./build-strategy.ts";
 import type {
   DeployInteraction,
   DeployProgress,
-  DestroyServiceProgress,
-  DestroyVersionInteraction,
-  DestroyVersionProgress,
+  DestroyAppProgress,
+  DestroyDeploymentInteraction,
+  DestroyDeploymentProgress,
   PromoteProgress,
   UpdateEnvProgress,
 } from "./callbacks.ts";
@@ -25,40 +25,40 @@ import {
   BuildError,
   CancelledError,
   type DeployError,
+  type DeploymentOperationError,
   DestroyAggregateError,
-  type DestroyServiceError,
-  type DestroyVersionError,
+  type DestroyAppError,
+  type DestroyDeploymentError,
   InvalidOptionsError,
   MissingArgumentError,
-  NoExistingVersionError,
-  NoVersionsFoundError,
+  NoDeploymentsFoundError,
+  NoExistingDeploymentError,
   type PromoteError,
   type UpdateEnvError,
-  type VersionOperationError,
 } from "./errors.ts";
-import { pollVersionStatus } from "./polling.ts";
+import { pollDeploymentStatus } from "./polling.ts";
 import type {
+  AppDetail,
+  AppInfo,
   CreateProjectResult,
+  DeploymentDetail,
+  DeploymentInfo,
   PortMapping,
   ProjectInfo,
   ResolvedConfig,
-  ServiceDetail,
-  ServiceInfo,
-  VersionDetail,
-  VersionInfo,
 } from "./types.ts";
 import { REGIONS } from "./types.ts";
 import { uploadArtifact } from "./upload-artifact.ts";
 
-type VersionDetailData = InferOk<
-  Awaited<ReturnType<InternalApiClient["getVersion"]>>
+type DeploymentDetailData = InferOk<
+  Awaited<ReturnType<InternalApiClient["getDeployment"]>>
 >;
 
 export interface DeployOptions {
   strategy: BuildStrategy;
   projectId?: string;
-  serviceId?: string;
-  serviceName?: string;
+  appId?: string;
+  appName?: string;
   region?: string;
   envVars?: Record<string, string | null>;
   portMapping?: PortMapping;
@@ -68,12 +68,12 @@ export interface DeployOptions {
   interaction?: DeployInteraction;
   progress?: DeployProgress;
   skipPromote?: boolean;
-  destroyOldVersion?: boolean;
+  destroyOldDeployment?: boolean;
 }
 
 export interface UpdateEnvOptions {
   projectId?: string;
-  serviceId?: string;
+  appId?: string;
   envVars?: Record<string, string | null>;
   portMapping?: PortMapping;
   timeoutSeconds?: number;
@@ -83,45 +83,45 @@ export interface UpdateEnvOptions {
   progress?: UpdateEnvProgress;
 }
 
-export interface DestroyVersionOptions {
-  versionId?: string;
-  serviceId?: string;
+export interface DestroyDeploymentOptions {
+  deploymentId?: string;
+  appId?: string;
   projectId?: string;
   timeoutSeconds?: number;
   pollIntervalMs?: number;
   signal?: AbortSignal;
-  interaction?: DestroyVersionInteraction;
-  progress?: DestroyVersionProgress;
+  interaction?: DestroyDeploymentInteraction;
+  progress?: DestroyDeploymentProgress;
 }
 
-export interface DestroyServiceOptions {
-  serviceId: string;
-  keepService?: boolean;
+export interface DestroyAppOptions {
+  appId: string;
+  keepApp?: boolean;
   timeoutSeconds?: number;
   pollIntervalMs?: number;
   signal?: AbortSignal;
-  progress?: DestroyServiceProgress;
+  progress?: DestroyAppProgress;
 }
 
-export interface ListServicesOptions {
+export interface ListAppsOptions {
   projectId: string;
   signal?: AbortSignal;
 }
 
-export interface CreateServiceOptions {
+export interface CreateAppOptions {
   projectId: string;
-  serviceName: string;
+  appName: string;
   region: string;
   signal?: AbortSignal;
 }
 
-export interface ShowServiceOptions {
-  serviceId: string;
+export interface ShowAppOptions {
+  appId: string;
   signal?: AbortSignal;
 }
 
-export interface DeleteServiceOptions {
-  serviceId: string;
+export interface DeleteAppOptions {
+  appId: string;
   signal?: AbortSignal;
 }
 
@@ -136,81 +136,81 @@ export interface ListProjectsOptions {
   signal?: AbortSignal;
 }
 
-export interface ListVersionsOptions {
-  serviceId: string;
+export interface ListDeploymentsOptions {
+  appId: string;
   signal?: AbortSignal;
 }
 
-export interface ShowVersionOptions {
-  versionId: string;
+export interface ShowDeploymentOptions {
+  deploymentId: string;
   signal?: AbortSignal;
 }
 
-export interface StartVersionOptions {
-  versionId: string;
+export interface StartDeploymentOptions {
+  deploymentId: string;
   signal?: AbortSignal;
 }
 
-export interface StopVersionOptions {
-  versionId: string;
+export interface StopDeploymentOptions {
+  deploymentId: string;
   signal?: AbortSignal;
 }
 
-export interface DeleteVersionOptions {
-  versionId: string;
+export interface DeleteDeploymentOptions {
+  deploymentId: string;
   signal?: AbortSignal;
 }
 
 export interface PromoteOptions {
-  serviceId: string;
-  versionId?: string;
+  appId: string;
+  deploymentId?: string;
   timeoutSeconds?: number;
   pollIntervalMs?: number;
   signal?: AbortSignal;
-  interaction?: DestroyVersionInteraction;
+  interaction?: DestroyDeploymentInteraction;
   progress?: PromoteProgress;
 }
 
 export interface DeployResult {
   projectId: string;
-  serviceId: string;
-  serviceName: string;
+  appId: string;
+  appName: string;
   region: string;
-  versionId: string;
-  versionEndpointDomain: string;
-  serviceEndpointDomain: string | null;
+  deploymentId: string;
+  deploymentEndpointDomain: string;
+  appEndpointDomain: string | null;
   promoted: boolean;
-  previousVersionId: string | null;
-  previousVersionAction: "stopped" | "destroyed" | "still-active" | null;
+  previousDeploymentId: string | null;
+  previousDeploymentAction: "stopped" | "destroyed" | "still-active" | null;
   resolvedConfig: ResolvedConfig;
 }
 
 export interface PromoteResult {
-  serviceId: string;
-  versionId: string;
-  serviceEndpointDomain: string;
-  versionStarted: boolean;
+  appId: string;
+  deploymentId: string;
+  appEndpointDomain: string;
+  deploymentStarted: boolean;
 }
 
 export interface UpdateEnvResult {
   projectId: string;
-  serviceId: string;
-  versionId: string;
+  appId: string;
+  deploymentId: string;
   deploymentUrl: string;
   resolvedConfig: ResolvedConfig;
 }
 
-export interface DestroyVersionResult {
-  versionId: string;
+export interface DestroyDeploymentResult {
+  deploymentId: string;
   previousStatus: string;
   stopped: boolean;
   deleted: boolean;
 }
 
-export interface DestroyServiceResult {
-  serviceId: string;
-  deletedVersionIds: string[];
-  serviceDeleted: boolean;
+export interface DestroyAppResult {
+  appId: string;
+  deletedDeploymentIds: string[];
+  appDeleted: boolean;
 }
 
 const DEFAULT_TIMEOUT_SECONDS = 120;
@@ -226,11 +226,11 @@ export class ComputeClient {
   async deploy(
     options: DeployOptions,
   ): Promise<Result<DeployResult, DeployError>> {
-    if (options.skipPromote && options.destroyOldVersion) {
+    if (options.skipPromote && options.destroyOldDeployment) {
       return Result.err(
         new InvalidOptionsError({
           message:
-            "destroyOldVersion cannot be combined with skipPromote — the old version stays active when promotion is skipped",
+            "destroyOldDeployment cannot be combined with skipPromote — the old deployment stays active when promotion is skipped",
         }),
       );
     }
@@ -281,7 +281,7 @@ export class ComputeClient {
 
         const portMapping =
           options.portMapping ??
-          (target.isNewService && artifact.defaultPortMapping
+          (target.isNewApp && artifact.defaultPortMapping
             ? artifact.defaultPortMapping
             : undefined);
 
@@ -295,19 +295,19 @@ export class ComputeClient {
         );
 
         const createResponse = yield* Result.await(
-          self.#api.createServiceVersion(
-            target.serviceId,
+          self.#api.createAppDeployment(
+            target.appId,
             portMapping ? { portMapping } : {},
             options.signal,
           ),
         );
-        options.progress?.onVersionCreated?.(createResponse.id);
+        options.progress?.onDeploymentCreated?.(createResponse.id);
 
         const uploadUrl = readUploadUrl(createResponse);
         if (!uploadUrl) {
           return Result.err(
             new ArtifactError({
-              message: "Version creation did not return an upload URL",
+              message: "Deployment creation did not return an upload URL",
             }),
           );
         }
@@ -322,18 +322,18 @@ export class ComputeClient {
 
         yield* self.#checkAborted(options.signal);
 
-        const service = yield* Result.await(
-          self.#api.getService(target.serviceId, options.signal),
+        const app = yield* Result.await(
+          self.#api.getApp(target.appId, options.signal),
         );
-        const previousVersionId = service.latestVersionId ?? null;
+        const previousDeploymentId = app.latestDeploymentId ?? null;
 
         options.progress?.onStartRequested?.();
         yield* Result.await(
-          self.#api.startVersion(createResponse.id, options.signal),
+          self.#api.startDeployment(createResponse.id, options.signal),
         );
 
         const pollResult = yield* Result.await(
-          pollVersionStatus(self.#api, createResponse.id, {
+          pollDeploymentStatus(self.#api, createResponse.id, {
             targetStatus: "running",
             timeoutSeconds: options.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS,
             pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
@@ -342,29 +342,31 @@ export class ComputeClient {
           }),
         );
 
-        const versionEndpointDomain = toDeploymentUrl(pollResult.previewDomain);
-        options.progress?.onRunning?.(versionEndpointDomain);
+        const deploymentEndpointDomain = toDeploymentUrl(
+          pollResult.previewDomain,
+        );
+        options.progress?.onRunning?.(deploymentEndpointDomain);
 
         const resolvedConfig: ResolvedConfig = {
           projectId: target.projectId,
-          serviceId: target.serviceId,
-          serviceName: target.serviceName,
+          appId: target.appId,
+          appName: target.appName,
           region: target.region,
-          portMapping: options.portMapping,
+          portMapping,
         };
 
         if (options.skipPromote) {
           return Result.ok({
             projectId: target.projectId,
-            serviceId: target.serviceId,
-            serviceName: target.serviceName,
+            appId: target.appId,
+            appName: target.appName,
             region: target.region,
-            versionId: createResponse.id,
-            versionEndpointDomain,
-            serviceEndpointDomain: null,
+            deploymentId: createResponse.id,
+            deploymentEndpointDomain,
+            appEndpointDomain: null,
             promoted: false,
-            previousVersionId,
-            previousVersionAction: previousVersionId
+            previousDeploymentId,
+            previousDeploymentAction: previousDeploymentId
               ? ("still-active" as const)
               : null,
             resolvedConfig,
@@ -373,10 +375,10 @@ export class ComputeClient {
 
         const switchoverResult = yield* Result.await(
           self.#promoteAndSwitchover(
-            target.serviceId,
+            target.appId,
             createResponse.id,
-            previousVersionId,
-            options.destroyOldVersion ?? false,
+            previousDeploymentId,
+            options.destroyOldDeployment ?? false,
             options.signal,
             options.progress,
           ),
@@ -384,15 +386,15 @@ export class ComputeClient {
 
         return Result.ok({
           projectId: target.projectId,
-          serviceId: target.serviceId,
-          serviceName: target.serviceName,
+          appId: target.appId,
+          appName: target.appName,
           region: target.region,
-          versionId: createResponse.id,
-          versionEndpointDomain,
-          serviceEndpointDomain: switchoverResult.serviceEndpointDomain,
+          deploymentId: createResponse.id,
+          deploymentEndpointDomain,
+          appEndpointDomain: switchoverResult.appEndpointDomain,
           promoted: true,
-          previousVersionId: switchoverResult.previousVersionId,
-          previousVersionAction: switchoverResult.previousVersionAction,
+          previousDeploymentId: switchoverResult.previousDeploymentId,
+          previousDeploymentAction: switchoverResult.previousDeploymentAction,
           resolvedConfig,
         });
       } finally {
@@ -410,12 +412,12 @@ export class ComputeClient {
 
       const target = yield* Result.await(self.#resolveDeployTarget(options));
 
-      const versions = yield* Result.await(
-        self.#api.listServiceVersions(target.serviceId, options.signal),
+      const deployments = yield* Result.await(
+        self.#api.listAppDeployments(target.appId, options.signal),
       );
-      if (versions.length === 0) {
+      if (deployments.length === 0) {
         return Result.err(
-          new NoExistingVersionError({ serviceId: target.serviceId }),
+          new NoExistingDeploymentError({ appId: target.appId }),
         );
       }
 
@@ -432,8 +434,8 @@ export class ComputeClient {
       yield* self.#checkAborted(options.signal);
 
       const createResponse = yield* Result.await(
-        self.#api.createServiceVersion(
-          target.serviceId,
+        self.#api.createAppDeployment(
+          target.appId,
           {
             ...(options.portMapping !== undefined
               ? { portMapping: options.portMapping }
@@ -443,17 +445,17 @@ export class ComputeClient {
           options.signal,
         ),
       );
-      options.progress?.onVersionCreated?.(createResponse.id);
+      options.progress?.onDeploymentCreated?.(createResponse.id);
 
       yield* self.#checkAborted(options.signal);
 
       options.progress?.onStartRequested?.();
       yield* Result.await(
-        self.#api.startVersion(createResponse.id, options.signal),
+        self.#api.startDeployment(createResponse.id, options.signal),
       );
 
       const pollResult = yield* Result.await(
-        pollVersionStatus(self.#api, createResponse.id, {
+        pollDeploymentStatus(self.#api, createResponse.id, {
           targetStatus: "running",
           timeoutSeconds: options.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS,
           pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
@@ -467,13 +469,13 @@ export class ComputeClient {
 
       return Result.ok({
         projectId: target.projectId,
-        serviceId: target.serviceId,
-        versionId: createResponse.id,
+        appId: target.appId,
+        deploymentId: createResponse.id,
         deploymentUrl,
         resolvedConfig: {
           projectId: target.projectId,
-          serviceId: target.serviceId,
-          serviceName: target.serviceName,
+          appId: target.appId,
+          appName: target.appName,
           region: target.region,
           portMapping: options.portMapping,
         },
@@ -481,74 +483,83 @@ export class ComputeClient {
     });
   }
 
-  async destroyVersion(
-    options: DestroyVersionOptions,
-  ): Promise<Result<DestroyVersionResult, DestroyVersionError>> {
+  async destroyDeployment(
+    options: DestroyDeploymentOptions,
+  ): Promise<Result<DestroyDeploymentResult, DestroyDeploymentError>> {
     const self = this;
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
 
-      let versionId = options.versionId;
-      let versionDetailsCache: Map<string, VersionDetailData> | undefined;
+      let deploymentId = options.deploymentId;
+      let deploymentDetailsCache: Map<string, DeploymentDetailData> | undefined;
 
-      if (!versionId) {
-        const serviceId = options.serviceId;
-        if (!serviceId) {
-          return Result.err(new MissingArgumentError({ field: "versionId" }));
+      if (!deploymentId) {
+        const appId = options.appId;
+        if (!appId) {
+          return Result.err(
+            new MissingArgumentError({ field: "deploymentId" }),
+          );
         }
 
-        const versions = yield* Result.await(
-          self.#api.listServiceVersions(serviceId, options.signal),
+        const deployments = yield* Result.await(
+          self.#api.listAppDeployments(appId, options.signal),
         );
-        const versionDetailResults = await Promise.all(
-          versions.map((v) => self.#api.getVersion(v.id, options.signal)),
+        const deploymentDetailResults = await Promise.all(
+          deployments.map((d) => self.#api.getDeployment(d.id, options.signal)),
         );
 
-        const details: VersionDetailData[] = [];
-        for (const result of versionDetailResults) {
+        const details: DeploymentDetailData[] = [];
+        for (const result of deploymentDetailResults) {
           if (result.isErr()) return result;
           details.push(result.value);
         }
 
-        versionDetailsCache = new Map(details.map((v) => [v.id, v]));
+        deploymentDetailsCache = new Map(details.map((d) => [d.id, d]));
 
-        const versionInfos = details
+        const deploymentInfos = details
           .map(
-            (v): VersionInfo => ({
-              id: v.id,
-              status: v.status,
-              createdAt: v.createdAt,
-              previewDomain: v.previewDomain,
+            (d): DeploymentInfo => ({
+              id: d.id,
+              status: d.status,
+              createdAt: d.createdAt,
+              previewDomain: d.previewDomain,
             }),
           )
-          .sort(versionSortComparator);
+          .sort(deploymentSortComparator);
 
-        if (versionInfos.length === 0) {
-          return Result.err(new NoVersionsFoundError({ serviceId }));
+        if (deploymentInfos.length === 0) {
+          return Result.err(new NoDeploymentsFoundError({ appId }));
         }
 
-        if (!options.interaction?.selectVersion) {
-          return Result.err(new MissingArgumentError({ field: "versionId" }));
+        if (!options.interaction?.selectDeployment) {
+          return Result.err(
+            new MissingArgumentError({ field: "deploymentId" }),
+          );
         }
 
-        versionId = await options.interaction.selectVersion(versionInfos);
+        deploymentId =
+          await options.interaction.selectDeployment(deploymentInfos);
       }
 
-      const version =
-        versionDetailsCache?.get(versionId) ??
-        (yield* Result.await(self.#api.getVersion(versionId, options.signal)));
+      const deployment =
+        deploymentDetailsCache?.get(deploymentId) ??
+        (yield* Result.await(
+          self.#api.getDeployment(deploymentId, options.signal),
+        ));
 
-      const previousStatus = version.status ?? "unknown";
+      const previousStatus = deployment.status ?? "unknown";
       const shouldStop =
-        version.status === "running" || version.status === "provisioning";
+        deployment.status === "running" || deployment.status === "provisioning";
       let stopped = false;
 
       if (shouldStop) {
-        options.progress?.onStopRequested?.(versionId);
-        yield* Result.await(self.#api.stopVersion(versionId, options.signal));
+        options.progress?.onStopRequested?.(deploymentId);
+        yield* Result.await(
+          self.#api.stopDeployment(deploymentId, options.signal),
+        );
 
         yield* Result.await(
-          pollVersionStatus(self.#api, versionId, {
+          pollDeploymentStatus(self.#api, deploymentId, {
             targetStatus: "stopped",
             timeoutSeconds: options.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS,
             pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
@@ -556,14 +567,16 @@ export class ComputeClient {
           }),
         );
         stopped = true;
-        options.progress?.onStopped?.(versionId);
+        options.progress?.onStopped?.(deploymentId);
       }
 
-      yield* Result.await(self.#api.deleteVersion(versionId, options.signal));
-      options.progress?.onDeleted?.(versionId);
+      yield* Result.await(
+        self.#api.deleteDeployment(deploymentId, options.signal),
+      );
+      options.progress?.onDeleted?.(deploymentId);
 
       return Result.ok({
-        versionId,
+        deploymentId,
         previousStatus,
         stopped,
         deleted: true,
@@ -571,9 +584,9 @@ export class ComputeClient {
     });
   }
 
-  async destroyService(
-    options: DestroyServiceOptions,
-  ): Promise<Result<DestroyServiceResult, DestroyServiceError>> {
+  async destroyApp(
+    options: DestroyAppOptions,
+  ): Promise<Result<DestroyAppResult, DestroyAppError>> {
     const self = this;
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
@@ -581,57 +594,57 @@ export class ComputeClient {
       const timeoutSeconds = options.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS;
       const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
 
-      const versions = yield* Result.await(
-        self.#api.listServiceVersions(options.serviceId, options.signal),
+      const deployments = yield* Result.await(
+        self.#api.listAppDeployments(options.appId, options.signal),
       );
-      const versionDetailResults = await Promise.all(
-        versions.map((v) => self.#api.getVersion(v.id, options.signal)),
+      const deploymentDetailResults = await Promise.all(
+        deployments.map((d) => self.#api.getDeployment(d.id, options.signal)),
       );
 
-      const versionDetails: VersionDetailData[] = [];
-      for (const result of versionDetailResults) {
+      const deploymentDetails: DeploymentDetailData[] = [];
+      for (const result of deploymentDetailResults) {
         if (result.isErr()) return result;
-        versionDetails.push(result.value);
+        deploymentDetails.push(result.value);
       }
 
-      const activeVersions = versionDetails.filter(
-        (v) => v.status === "running" || v.status === "provisioning",
+      const activeDeployments = deploymentDetails.filter(
+        (d) => d.status === "running" || d.status === "provisioning",
       );
 
       const succeededIds: string[] = [];
       const failures: Array<{
-        versionId: string;
-        error: VersionOperationError;
+        deploymentId: string;
+        error: DeploymentOperationError;
       }> = [];
 
-      if (activeVersions.length > 0) {
-        const activeIds = activeVersions.map((v) => v.id);
-        options.progress?.onStoppingVersions?.(activeIds);
+      if (activeDeployments.length > 0) {
+        const activeIds = activeDeployments.map((d) => d.id);
+        options.progress?.onStoppingDeployments?.(activeIds);
 
         const stopResults = await Promise.all(
-          activeVersions.map((v) =>
-            self.#api.stopVersion(v.id, options.signal),
+          activeDeployments.map((d) =>
+            self.#api.stopDeployment(d.id, options.signal),
           ),
         );
 
-        const stoppedCandidates: typeof activeVersions = [];
+        const stoppedCandidates: typeof activeDeployments = [];
         for (const [i, result] of stopResults.entries()) {
           // biome-ignore lint/style/noNonNullAssertion: both lists have the same length
-          const activeVersion = activeVersions[i]!;
+          const activeDeployment = activeDeployments[i]!;
           if (result.isErr()) {
             failures.push({
-              versionId: activeVersion.id,
+              deploymentId: activeDeployment.id,
               error: result.error,
             });
           } else {
-            stoppedCandidates.push(activeVersion);
+            stoppedCandidates.push(activeDeployment);
           }
         }
 
         if (stoppedCandidates.length > 0) {
           const pollResults = await Promise.all(
-            stoppedCandidates.map((v) =>
-              pollVersionStatus(self.#api, v.id, {
+            stoppedCandidates.map((d) =>
+              pollDeploymentStatus(self.#api, d.id, {
                 targetStatus: "stopped",
                 timeoutSeconds,
                 pollIntervalMs,
@@ -642,14 +655,14 @@ export class ComputeClient {
 
           for (const [i, result] of pollResults.entries()) {
             // biome-ignore lint/style/noNonNullAssertion: both lists have the same length
-            const stoppedVersion = stoppedCandidates[i]!;
+            const stoppedDeployment = stoppedCandidates[i]!;
             if (result.isErr()) {
               failures.push({
-                versionId: stoppedVersion.id,
+                deploymentId: stoppedDeployment.id,
                 error: result.error,
               });
             } else {
-              options.progress?.onVersionStopped?.(stoppedVersion.id);
+              options.progress?.onDeploymentStopped?.(stoppedDeployment.id);
             }
           }
         }
@@ -657,64 +670,64 @@ export class ComputeClient {
         if (failures.length > 0) {
           return Result.err(
             new DestroyAggregateError({
-              succeededVersionIds: succeededIds,
+              succeededDeploymentIds: succeededIds,
               failures,
-              serviceDeleted: false,
+              appDeleted: false,
             }),
           );
         }
 
-        options.progress?.onAllVersionsStopped?.();
+        options.progress?.onAllDeploymentsStopped?.();
       }
 
-      if (versions.length > 0) {
-        const versionIds = versions.map((v) => v.id);
-        options.progress?.onDeletingVersions?.(versionIds);
+      if (deployments.length > 0) {
+        const deploymentIds = deployments.map((d) => d.id);
+        options.progress?.onDeletingDeployments?.(deploymentIds);
 
         const deleteResults = await Promise.all(
-          versions.map((v) => self.#api.deleteVersion(v.id, options.signal)),
+          deployments.map((d) =>
+            self.#api.deleteDeployment(d.id, options.signal),
+          ),
         );
 
         for (const [i, result] of deleteResults.entries()) {
           // biome-ignore lint/style/noNonNullAssertion: both lists have the same length
-          const version = versions[i]!;
+          const deployment = deployments[i]!;
           if (result.isErr()) {
             failures.push({
-              versionId: version.id,
+              deploymentId: deployment.id,
               error: result.error,
             });
           } else {
-            succeededIds.push(version.id);
-            options.progress?.onVersionDeleted?.(version.id);
+            succeededIds.push(deployment.id);
+            options.progress?.onDeploymentDeleted?.(deployment.id);
           }
         }
 
         if (failures.length > 0) {
           return Result.err(
             new DestroyAggregateError({
-              succeededVersionIds: succeededIds,
+              succeededDeploymentIds: succeededIds,
               failures,
-              serviceDeleted: false,
+              appDeleted: false,
             }),
           );
         }
 
-        options.progress?.onAllVersionsDeleted?.();
+        options.progress?.onAllDeploymentsDeleted?.();
       }
 
-      let serviceDeleted = false;
-      if (!options.keepService) {
-        yield* Result.await(
-          self.#api.deleteService(options.serviceId, options.signal),
-        );
-        serviceDeleted = true;
-        options.progress?.onServiceDeleted?.(options.serviceId);
+      let appDeleted = false;
+      if (!options.keepApp) {
+        yield* Result.await(self.#api.deleteApp(options.appId, options.signal));
+        appDeleted = true;
+        options.progress?.onAppDeleted?.(options.appId);
       }
 
       return Result.ok({
-        serviceId: options.serviceId,
-        deletedVersionIds: succeededIds,
-        serviceDeleted,
+        appId: options.appId,
+        deletedDeploymentIds: succeededIds,
+        appDeleted,
       });
     });
   }
@@ -779,39 +792,39 @@ export class ComputeClient {
     });
   }
 
-  async listServices(
-    options: ListServicesOptions,
-  ): Promise<Result<ServiceInfo[], ApiRequestError>> {
+  async listApps(
+    options: ListAppsOptions,
+  ): Promise<Result<AppInfo[], ApiRequestError>> {
     const self = this;
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
-      const services = yield* Result.await(
-        self.#api.listProjectServices(options.projectId, options.signal),
+      const apps = yield* Result.await(
+        self.#api.listProjectApps(options.projectId, options.signal),
       );
       return Result.ok(
-        services.map(
-          (s): ServiceInfo => ({
-            id: s.id,
-            name: s.name,
-            region: s.region.id,
-            projectId: s.projectId,
+        apps.map(
+          (a): AppInfo => ({
+            id: a.id,
+            name: a.name,
+            region: a.region.id,
+            projectId: a.projectId,
           }),
         ),
       );
     });
   }
 
-  async createService(
-    options: CreateServiceOptions,
-  ): Promise<Result<ServiceInfo, ApiRequestError>> {
+  async createApp(
+    options: CreateAppOptions,
+  ): Promise<Result<AppInfo, ApiRequestError>> {
     const self = this;
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
       const response = yield* Result.await(
-        self.#api.createProjectService(
+        self.#api.createProjectApp(
           options.projectId,
           {
-            displayName: options.serviceName,
+            displayName: options.appName,
             regionId: options.region,
           },
           options.signal,
@@ -826,56 +839,54 @@ export class ComputeClient {
     });
   }
 
-  async showService(
-    options: ShowServiceOptions,
-  ): Promise<Result<ServiceDetail, ApiRequestError>> {
+  async showApp(
+    options: ShowAppOptions,
+  ): Promise<Result<AppDetail, ApiRequestError>> {
     const self = this;
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
-      const s = yield* Result.await(
-        self.#api.getService(options.serviceId, options.signal),
+      const a = yield* Result.await(
+        self.#api.getApp(options.appId, options.signal),
       );
       return Result.ok({
-        id: s.id,
-        name: s.name,
-        region: s.region.id,
-        projectId: s.projectId,
-        latestVersionId: s.latestVersionId,
-        serviceEndpointDomain: s.serviceEndpointDomain,
+        id: a.id,
+        name: a.name,
+        region: a.region.id,
+        projectId: a.projectId,
+        latestDeploymentId: a.latestDeploymentId,
+        appEndpointDomain: a.appEndpointDomain,
       });
     });
   }
 
-  async deleteService(
-    options: DeleteServiceOptions,
+  async deleteApp(
+    options: DeleteAppOptions,
   ): Promise<Result<void, ApiRequestError>> {
     const self = this;
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
-      yield* Result.await(
-        self.#api.deleteService(options.serviceId, options.signal),
-      );
+      yield* Result.await(self.#api.deleteApp(options.appId, options.signal));
       return Result.ok();
     });
   }
 
-  async listVersions(
-    options: ListVersionsOptions,
-  ): Promise<Result<VersionInfo[], ApiRequestError>> {
+  async listDeployments(
+    options: ListDeploymentsOptions,
+  ): Promise<Result<DeploymentInfo[], ApiRequestError>> {
     const self = this;
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
-      const versions = yield* Result.await(
-        self.#api.listServiceVersions(options.serviceId, options.signal),
+      const deployments = yield* Result.await(
+        self.#api.listAppDeployments(options.appId, options.signal),
       );
       const detailResults = await Promise.all(
-        versions.map((v) => self.#api.getVersion(v.id, options.signal)),
+        deployments.map((d) => self.#api.getDeployment(d.id, options.signal)),
       );
-      const details: VersionDetailData[] = [];
+      const details: DeploymentDetailData[] = [];
       for (const result of detailResults) {
         if (result.isErr()) {
-          // listServiceVersions returns versions that have previously been deleted
-          // and can't be fetched using getVersion so we need to filter those out.
+          // listAppDeployments returns deployments that have previously been deleted
+          // and can't be fetched using getDeployment so we need to filter those out.
           if (ApiError.is(result.error) && result.error.statusCode === 404)
             continue;
           return result;
@@ -884,70 +895,70 @@ export class ComputeClient {
       }
       return Result.ok(
         details.map(
-          (v): VersionInfo => ({
-            id: v.id,
-            status: v.status,
-            createdAt: v.createdAt,
-            previewDomain: v.previewDomain,
+          (d): DeploymentInfo => ({
+            id: d.id,
+            status: d.status,
+            createdAt: d.createdAt,
+            previewDomain: d.previewDomain,
           }),
         ),
       );
     });
   }
 
-  async showVersion(
-    options: ShowVersionOptions,
-  ): Promise<Result<VersionDetail, ApiRequestError>> {
+  async showDeployment(
+    options: ShowDeploymentOptions,
+  ): Promise<Result<DeploymentDetail, ApiRequestError>> {
     const self = this;
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
-      const v = yield* Result.await(
-        self.#api.getVersion(options.versionId, options.signal),
+      const d = yield* Result.await(
+        self.#api.getDeployment(options.deploymentId, options.signal),
       );
       return Result.ok({
-        id: v.id,
-        status: v.status,
-        createdAt: v.createdAt,
-        previewDomain: v.previewDomain,
-        envVars: v.envVars ?? undefined,
+        id: d.id,
+        status: d.status,
+        createdAt: d.createdAt,
+        previewDomain: d.previewDomain,
+        envVars: d.envVars ?? undefined,
       });
     });
   }
 
-  async startVersion(
-    options: StartVersionOptions,
+  async startDeployment(
+    options: StartDeploymentOptions,
   ): Promise<Result<void, ApiRequestError>> {
     const self = this;
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
       yield* Result.await(
-        self.#api.startVersion(options.versionId, options.signal),
+        self.#api.startDeployment(options.deploymentId, options.signal),
       );
       return Result.ok();
     });
   }
 
-  async stopVersion(
-    options: StopVersionOptions,
+  async stopDeployment(
+    options: StopDeploymentOptions,
   ): Promise<Result<void, ApiRequestError>> {
     const self = this;
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
       yield* Result.await(
-        self.#api.stopVersion(options.versionId, options.signal),
+        self.#api.stopDeployment(options.deploymentId, options.signal),
       );
       return Result.ok();
     });
   }
 
-  async deleteVersion(
-    options: DeleteVersionOptions,
+  async deleteDeployment(
+    options: DeleteDeploymentOptions,
   ): Promise<Result<void, ApiRequestError>> {
     const self = this;
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
       yield* Result.await(
-        self.#api.deleteVersion(options.versionId, options.signal),
+        self.#api.deleteDeployment(options.deploymentId, options.signal),
       );
       return Result.ok();
     });
@@ -960,16 +971,16 @@ export class ComputeClient {
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
 
-      let versionId = options.versionId;
+      let deploymentId = options.deploymentId;
 
-      if (!versionId) {
-        const versions = yield* Result.await(
-          self.#api.listServiceVersions(options.serviceId, options.signal),
+      if (!deploymentId) {
+        const deployments = yield* Result.await(
+          self.#api.listAppDeployments(options.appId, options.signal),
         );
         const detailResults = await Promise.all(
-          versions.map((v) => self.#api.getVersion(v.id, options.signal)),
+          deployments.map((d) => self.#api.getDeployment(d.id, options.signal)),
         );
-        const details: VersionDetailData[] = [];
+        const details: DeploymentDetailData[] = [];
         for (const result of detailResults) {
           if (result.isErr()) {
             if (ApiError.is(result.error) && result.error.statusCode === 404)
@@ -979,42 +990,45 @@ export class ComputeClient {
           details.push(result.value);
         }
 
-        const versionInfos = details
+        const deploymentInfos = details
           .map(
-            (v): VersionInfo => ({
-              id: v.id,
-              status: v.status,
-              createdAt: v.createdAt,
-              previewDomain: v.previewDomain,
+            (d): DeploymentInfo => ({
+              id: d.id,
+              status: d.status,
+              createdAt: d.createdAt,
+              previewDomain: d.previewDomain,
             }),
           )
-          .sort(versionSortComparator);
+          .sort(deploymentSortComparator);
 
-        if (versionInfos.length === 0) {
+        if (deploymentInfos.length === 0) {
           return Result.err(
-            new NoVersionsFoundError({ serviceId: options.serviceId }),
+            new NoDeploymentsFoundError({ appId: options.appId }),
           );
         }
 
-        if (!options.interaction?.selectVersion) {
-          return Result.err(new MissingArgumentError({ field: "versionId" }));
+        if (!options.interaction?.selectDeployment) {
+          return Result.err(
+            new MissingArgumentError({ field: "deploymentId" }),
+          );
         }
 
-        versionId = await options.interaction.selectVersion(versionInfos);
+        deploymentId =
+          await options.interaction.selectDeployment(deploymentInfos);
       }
 
-      const version = yield* Result.await(
-        self.#api.getVersion(versionId, options.signal),
+      const deployment = yield* Result.await(
+        self.#api.getDeployment(deploymentId, options.signal),
       );
-      let versionStarted = false;
+      let deploymentStarted = false;
 
-      if (version.status !== "running") {
-        options.progress?.onVersionStarting?.(versionId);
+      if (deployment.status !== "running") {
+        options.progress?.onDeploymentStarting?.(deploymentId);
 
-        if (version.status !== "provisioning") {
-          options.progress?.onVersionStartRequested?.();
-          const startResult = await self.#api.startVersion(
-            versionId,
+        if (deployment.status !== "provisioning") {
+          options.progress?.onDeploymentStartRequested?.();
+          const startResult = await self.#api.startDeployment(
+            deploymentId,
             options.signal,
           );
           if (startResult.isErr()) {
@@ -1023,7 +1037,7 @@ export class ComputeClient {
           }
         }
 
-        const pollResult = await pollVersionStatus(self.#api, versionId, {
+        const pollResult = await pollDeploymentStatus(self.#api, deploymentId, {
           targetStatus: "running",
           timeoutSeconds: options.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS,
           pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
@@ -1034,75 +1048,82 @@ export class ComputeClient {
           options.progress?.onPromoteFailed?.(pollResult.error);
           return pollResult;
         }
-        versionStarted = true;
-        options.progress?.onVersionRunning?.();
+        deploymentStarted = true;
+        options.progress?.onDeploymentRunning?.();
       }
 
       options.progress?.onPromoteStart?.();
-      const promoteResult = await self.#api.promoteService(
-        options.serviceId,
-        { versionId },
+      const promoteResult = await self.#api.promoteApp(
+        options.appId,
+        { deploymentId },
         options.signal,
       );
       if (promoteResult.isErr()) {
         options.progress?.onPromoteFailed?.(promoteResult.error);
         return promoteResult;
       }
-      options.progress?.onPromoted?.(promoteResult.value.serviceEndpointDomain);
+      options.progress?.onPromoted?.(promoteResult.value.appEndpointDomain);
 
       return Result.ok({
-        serviceId: options.serviceId,
-        versionId,
-        serviceEndpointDomain: promoteResult.value.serviceEndpointDomain,
-        versionStarted,
+        appId: options.appId,
+        deploymentId,
+        appEndpointDomain: promoteResult.value.appEndpointDomain,
+        deploymentStarted,
       });
     });
   }
 
   async #promoteAndSwitchover(
-    serviceId: string,
-    newVersionId: string,
-    previousVersionId: string | null,
-    destroyOldVersion: boolean,
+    appId: string,
+    newDeploymentId: string,
+    previousDeploymentId: string | null,
+    destroyOldDeployment: boolean,
     signal?: AbortSignal,
     progress?: DeployProgress,
   ): Promise<
     Result<
       {
-        serviceEndpointDomain: string;
-        previousVersionId: string | null;
-        previousVersionAction: "stopped" | "destroyed" | null;
+        appEndpointDomain: string;
+        previousDeploymentId: string | null;
+        previousDeploymentAction: "stopped" | "destroyed" | null;
       },
       DeployError
     >
   > {
     progress?.onPromoteStart?.();
-    const promoteResult = await this.#api.promoteService(
-      serviceId,
-      { versionId: newVersionId },
+    const promoteResult = await this.#api.promoteApp(
+      appId,
+      { deploymentId: newDeploymentId },
       signal,
     );
 
     if (promoteResult.isErr()) {
       progress?.onPromoteFailed?.(promoteResult.error);
-      progress?.onCleanupDanglingVersion?.(newVersionId);
-      await this.#cleanupDanglingVersion(newVersionId, undefined, progress);
+      progress?.onCleanupDanglingDeployment?.(newDeploymentId);
+      await this.#cleanupDanglingDeployment(
+        newDeploymentId,
+        undefined,
+        progress,
+      );
       return promoteResult;
     }
 
-    const serviceEndpointDomain = promoteResult.value.serviceEndpointDomain;
-    progress?.onPromoted?.(serviceEndpointDomain);
+    const appEndpointDomain = promoteResult.value.appEndpointDomain;
+    progress?.onPromoted?.(appEndpointDomain);
 
-    let previousVersionAction: "stopped" | "destroyed" | null = null;
+    let previousDeploymentAction: "stopped" | "destroyed" | null = null;
 
-    if (previousVersionId && previousVersionId !== newVersionId) {
-      progress?.onOldVersionStopping?.(previousVersionId);
-      const stopResult = await this.#api.stopVersion(previousVersionId, signal);
+    if (previousDeploymentId && previousDeploymentId !== newDeploymentId) {
+      progress?.onOldDeploymentStopping?.(previousDeploymentId);
+      const stopResult = await this.#api.stopDeployment(
+        previousDeploymentId,
+        signal,
+      );
 
       if (stopResult.isOk()) {
-        const pollResult = await pollVersionStatus(
+        const pollResult = await pollDeploymentStatus(
           this.#api,
-          previousVersionId,
+          previousDeploymentId,
           {
             targetStatus: "stopped",
             timeoutSeconds: 30,
@@ -1112,66 +1133,66 @@ export class ComputeClient {
         );
 
         if (pollResult.isOk()) {
-          previousVersionAction = "stopped";
-          progress?.onOldVersionStopped?.(previousVersionId);
+          previousDeploymentAction = "stopped";
+          progress?.onOldDeploymentStopped?.(previousDeploymentId);
 
-          if (destroyOldVersion) {
-            progress?.onOldVersionDeleting?.(previousVersionId);
-            const deleteResult = await this.#api.deleteVersion(
-              previousVersionId,
+          if (destroyOldDeployment) {
+            progress?.onOldDeploymentDeleting?.(previousDeploymentId);
+            const deleteResult = await this.#api.deleteDeployment(
+              previousDeploymentId,
               signal,
             );
             if (deleteResult.isOk()) {
-              previousVersionAction = "destroyed";
-              progress?.onOldVersionDeleted?.(previousVersionId);
+              previousDeploymentAction = "destroyed";
+              progress?.onOldDeploymentDeleted?.(previousDeploymentId);
             } else {
-              progress?.onOldVersionDeleteFailed?.(previousVersionId);
+              progress?.onOldDeploymentDeleteFailed?.(previousDeploymentId);
             }
           }
         } else {
-          progress?.onOldVersionStopFailed?.(previousVersionId);
+          progress?.onOldDeploymentStopFailed?.(previousDeploymentId);
         }
       } else {
-        progress?.onOldVersionStopFailed?.(previousVersionId);
+        progress?.onOldDeploymentStopFailed?.(previousDeploymentId);
       }
     }
 
     return Result.ok({
-      serviceEndpointDomain,
-      previousVersionId,
-      previousVersionAction,
+      appEndpointDomain,
+      previousDeploymentId,
+      previousDeploymentAction,
     });
   }
 
-  async #cleanupDanglingVersion(
-    versionId: string,
+  async #cleanupDanglingDeployment(
+    deploymentId: string,
     signal?: AbortSignal,
     progress?: DeployProgress,
   ): Promise<void> {
-    const stopResult = await this.#api.stopVersion(versionId, signal);
+    const stopResult = await this.#api.stopDeployment(deploymentId, signal);
     if (stopResult.isErr()) {
-      progress?.onCleanupDanglingVersionFailed?.(versionId);
+      progress?.onCleanupDanglingDeploymentFailed?.(deploymentId);
       return;
     }
 
-    const pollResult = await pollVersionStatus(this.#api, versionId, {
+    const pollResult = await pollDeploymentStatus(this.#api, deploymentId, {
       targetStatus: "stopped",
       timeoutSeconds: 30,
       pollIntervalMs: 1000,
       signal,
     });
     if (pollResult.isErr()) {
-      progress?.onCleanupDanglingVersionFailed?.(versionId);
+      progress?.onCleanupDanglingDeploymentFailed?.(deploymentId);
       return;
     }
 
-    const deleteResult = await this.#api.deleteVersion(versionId, signal);
+    const deleteResult = await this.#api.deleteDeployment(deploymentId, signal);
     if (deleteResult.isErr()) {
-      progress?.onCleanupDanglingVersionFailed?.(versionId);
+      progress?.onCleanupDanglingDeploymentFailed?.(deploymentId);
       return;
     }
 
-    progress?.onCleanupDanglingVersionComplete?.(versionId);
+    progress?.onCleanupDanglingDeploymentComplete?.(deploymentId);
   }
 
   #checkAborted(signal?: AbortSignal): Result<void, CancelledError> {
@@ -1185,8 +1206,8 @@ export class ComputeClient {
 
   async #resolveDeployTarget(options: {
     projectId?: string;
-    serviceId?: string;
-    serviceName?: string;
+    appId?: string;
+    appName?: string;
     region?: string;
     signal?: AbortSignal;
     interaction?: DeployInteraction;
@@ -1194,11 +1215,11 @@ export class ComputeClient {
     Result<
       {
         projectId: string;
-        serviceId: string;
-        serviceName: string;
+        appId: string;
+        appName: string;
         region: string;
         branchId: string | null;
-        isNewService: boolean;
+        isNewApp: boolean;
       },
       | MissingArgumentError
       | CancelledError
@@ -1209,32 +1230,32 @@ export class ComputeClient {
   > {
     const self = this;
     return Result.gen(async function* () {
-      if (options.serviceId) {
-        const service = yield* Result.await(
-          self.#api.getService(options.serviceId, options.signal),
+      if (options.appId) {
+        const app = yield* Result.await(
+          self.#api.getApp(options.appId, options.signal),
         );
-        if (!service.projectId) {
+        if (!app.projectId) {
           return Result.err(new MissingArgumentError({ field: "projectId" }));
         }
         const requestedProjectId = options.projectId?.replace(/^proj_/, "");
-        const serviceProjectId = service.projectId.replace(/^proj_/, "");
+        const appProjectId = app.projectId.replace(/^proj_/, "");
         if (
           requestedProjectId !== undefined &&
-          requestedProjectId !== serviceProjectId
+          requestedProjectId !== appProjectId
         ) {
           return Result.err(
             new InvalidOptionsError({
-              message: `Service ${service.id} belongs to project ${service.projectId}, but project ${options.projectId} was provided`,
+              message: `App ${app.id} belongs to project ${app.projectId}, but project ${options.projectId} was provided`,
             }),
           );
         }
         return Result.ok({
-          projectId: service.projectId,
-          serviceId: service.id,
-          serviceName: service.name ?? service.id,
-          region: service.region.id,
-          branchId: service.branchId ?? null,
-          isNewService: false,
+          projectId: app.projectId,
+          appId: app.id,
+          appName: app.name ?? app.id,
+          region: app.region.id,
+          branchId: app.branchId ?? null,
+          isNewApp: false,
         });
       }
 
@@ -1258,12 +1279,12 @@ export class ComputeClient {
         projectId = await options.interaction.selectProject(projectInfos);
       }
 
-      if (options.serviceName && options.region) {
+      if (options.appName && options.region) {
         const response = yield* Result.await(
-          self.#api.createProjectService(
+          self.#api.createProjectApp(
             projectId,
             {
-              displayName: options.serviceName,
+              displayName: options.appName,
               regionId: options.region,
             },
             options.signal,
@@ -1271,58 +1292,54 @@ export class ComputeClient {
         );
         return Result.ok({
           projectId,
-          serviceId: response.id,
-          serviceName: response.name,
+          appId: response.id,
+          appName: response.name,
           region: response.region.id,
           branchId: response.branchId ?? null,
-          isNewService: true,
+          isNewApp: true,
         });
       }
 
-      const services = yield* Result.await(
-        self.#api.listProjectServices(projectId, options.signal),
+      const apps = yield* Result.await(
+        self.#api.listProjectApps(projectId, options.signal),
       );
-      const serviceInfos = services.map(
-        (s): ServiceInfo => ({
-          id: s.id,
-          name: s.name,
-          region: s.region.id,
-          projectId: s.projectId,
+      const appInfos = apps.map(
+        (a): AppInfo => ({
+          id: a.id,
+          name: a.name,
+          region: a.region.id,
+          projectId: a.projectId,
         }),
       );
 
-      if (!options.interaction?.selectService) {
-        return Result.err(new MissingArgumentError({ field: "serviceId" }));
+      if (!options.interaction?.selectApp) {
+        return Result.err(new MissingArgumentError({ field: "appId" }));
       }
 
-      const selectedServiceId =
-        await options.interaction.selectService(serviceInfos);
+      const selectedAppId = await options.interaction.selectApp(appInfos);
 
-      if (selectedServiceId !== null) {
-        const selected = services.find((s) => s.id === selectedServiceId);
-        invariant(
-          selected,
-          "selectService returned service ID not in the list",
-        );
-        const service = yield* Result.await(
-          self.#api.getService(selectedServiceId, options.signal),
+      if (selectedAppId !== null) {
+        const selected = apps.find((a) => a.id === selectedAppId);
+        invariant(selected, "selectApp returned app ID not in the list");
+        const app = yield* Result.await(
+          self.#api.getApp(selectedAppId, options.signal),
         );
         return Result.ok({
           projectId,
-          serviceId: selectedServiceId,
-          serviceName: service.name ?? selected.name,
-          region: service.region.id,
-          branchId: service.branchId ?? null,
-          isNewService: false,
+          appId: selectedAppId,
+          appName: app.name ?? selected.name,
+          region: app.region.id,
+          branchId: app.branchId ?? null,
+          isNewApp: false,
         });
       }
 
-      let serviceName = options.serviceName;
-      if (!serviceName) {
-        if (!options.interaction?.provideServiceName) {
-          return Result.err(new MissingArgumentError({ field: "serviceName" }));
+      let appName = options.appName;
+      if (!appName) {
+        if (!options.interaction?.provideAppName) {
+          return Result.err(new MissingArgumentError({ field: "appName" }));
         }
-        serviceName = await options.interaction.provideServiceName();
+        appName = await options.interaction.provideAppName();
       }
 
       let region = options.region;
@@ -1334,10 +1351,10 @@ export class ComputeClient {
       }
 
       const response = yield* Result.await(
-        self.#api.createProjectService(
+        self.#api.createProjectApp(
           projectId,
           {
-            displayName: serviceName,
+            displayName: appName,
             regionId: region,
           },
           options.signal,
@@ -1346,11 +1363,11 @@ export class ComputeClient {
 
       return Result.ok({
         projectId,
-        serviceId: response.id,
-        serviceName: response.name,
+        appId: response.id,
+        appName: response.name,
         region: response.region.id,
         branchId: response.branchId ?? null,
-        isNewService: true,
+        isNewApp: true,
       });
     });
   }
@@ -1458,9 +1475,12 @@ export class ComputeClient {
 }
 
 /**
- * Sort versions: running/provisioning first, then by createdAt descending.
+ * Sort deployments: running/provisioning first, then by createdAt descending.
  */
-function versionSortComparator(a: VersionInfo, b: VersionInfo): number {
+function deploymentSortComparator(
+  a: DeploymentInfo,
+  b: DeploymentInfo,
+): number {
   const statusPriority = (s: string) =>
     s === "running" ? 0 : s === "provisioning" ? 1 : 2;
   const aPriority = statusPriority(a.status);