alchemy 2.0.0-beta.76 → 2.0.0-beta.78

package/lib/Prisma/Compute.js

@@ -27,10 +27,11 @@ import { Resource } from "../Resource.js";
 import { RuntimeContext } from "../RuntimeContext.js";
 import { Stack } from "../Stack.js";
 import { sha256Object } from "../Util/sha256.js";
-import { PrismaApiError, PrismaClient, isNotFound, } from "./Client.js";
-import { runBuildCommand, runComputeAutoBuild, } from "./ComputeBuild.js";
+import { Retry } from "@distilled.cloud/prisma";
+import { deleteEnvironmentVariable, getServices, getService, getBranch, getEnvironmentVariables, getProjectBranches, updateService, updateEnvironmentVariable, createService, createServiceDeployment, createServiceRollback, createEnvironmentVariable, } from "@distilled.cloud/prisma/management";
+import { runBuildCommand, runComputeAutoBuild, runComputeStaticBuild, } from "./ComputeBuild.js";
 import { createComputeArchive, normalizeEntrypoint } from "./ComputeArchive.js";
-import { destroyApp, destroyDeployment, isConflict, toDeploymentUrl, waitForDeploymentStatus, } from "./ComputeLifecycle.js";
+import { destroyApp, destroyDeployment, toDeploymentUrl, waitForDeploymentStatus, } from "./ComputeLifecycle.js";
 import { startDeploymentIdempotent, stopDeploymentIdempotent, } from "./Internal/DeploymentActions.js";
 import { ensureAppImmutableIdentity } from "./Internal/AppIdentity.js";
 import { promoteAppObserved, waitForAppDeploymentTarget, } from "./Internal/AppPromotion.js";
@@ -40,6 +41,7 @@ import { ensureDeploymentMembership } from "./Internal/DeploymentIdentity.js";
 import { observeDeployment } from "./Internal/DeploymentObserve.js";
 import { tailDeploymentLogs } from "./PrismaLogs.js";
 import { concreteIdsChanged, isInputObject, isPrismaDevId, resolveProjectId, unresolvedProjectIdOf, } from "./Refs.js";
+import { PrismaPaginationError } from "./Internal/Pagination.js";
 import { readUploadArtifact, uploadArtifact } from "./Deployment.js";
 const ComputeTypeId = "Prisma.Compute";
 export const isCompute = (value) => typeof value === "object" &&
@@ -90,16 +92,13 @@ const isEffectNativeCompute = (props) => hasEffectNativeComputeInput(props);
  * ```
  *
  * ### Bundling & Tree-shaking
- * `main` is bundled with rolldown at deploy time. Top-level calls in the
- * `effect`, `@effect/*`, `alchemy`, `@alchemy.run/*`, and
- * `@distilled.cloud/*` packages receive `#__PURE__` annotations by
- * default, so anything the app doesn't use from those packages is
- * tree-shaken out of the bundle. Any other package — including your own
- * app — is left untouched unless you list it explicitly.
+ * `main` is bundled with rolldown at deploy time. Unused code is
+ * tree-shaken. `effect`, alchemy, and `@distilled.cloud` are marked
+ * pure so unused parts prune more aggressively. Your app is not
+ * marked pure.
  *
- * **Example:** Treat additional packages as pure
- * Pass package names (or picomatch globs) via `bundle.extra.pure.packages` to
- * annotate them in addition to the defaults.
+ * **Example:** Mark additional packages as pure
+ * Only list packages with no top-level side effects.
  * ```typescript
  * {
  *   main: "./src/app.ts",
@@ -109,18 +108,7 @@ const isEffectNativeCompute = (props) => hasEffectNativeComputeInput(props);
  * }
  * ```
  *
- * Listing a package annotates calls whose result is bound (variable
- * initializers, exports) — safe anywhere. If a listed package also
- * declares `"sideEffects": false` (or `[]`) in its `package.json`, that
- * combination opts it into full annotation: top-level calls whose result
- * is discarded (e.g. `router.on("/path", handler)` registrations) are
- * also marked pure and deleted under minification when unused. Only list
- * a `sideEffects: false` package if its modules really are free of
- * meaningful top-level side effects. The `effect`, `alchemy`, and
- * `@distilled.cloud` defaults declare exactly that, on purpose — their
- * modules are designed to be fully tree-shakeable.
- *
- * **Example:** Disable pure annotations
+ * **Example:** Turn it off
  * ```typescript
  * {
  *   main: "./src/app.ts",
@@ -182,6 +170,18 @@ const isEffectNativeCompute = (props) => hasEffectNativeComputeInput(props);
  * });
  * ```
  *
+ * **Example:** Deploy a static site
+ * ```typescript
+ * const web = yield* Prisma.Compute("web", {
+ *   project,
+ *   path: "./site",
+ *   build: {
+ *     type: "static",
+ *     outdir: ".",
+ *   },
+ * });
+ * ```
+ *
  * **Example:** Deploy a prebuilt tar.gz artifact
  * ```typescript
  * const app = yield* Prisma.Compute("api", {
@@ -305,18 +305,63 @@ const projectConsistencySchedule = Schedule.max([
     Schedule.exponential(Duration.millis(500)),
     Schedule.recurs(6),
 ]);
-const isAppProvisioningNotFound = (error) => error instanceof PrismaApiError &&
-    error.status === 404 &&
-    (error.path.startsWith("/v1/projects/") ||
-        error.path === "/v1/apps" ||
-        error.path.startsWith("/v1/apps/"));
-const desiredComputeBranchId = Effect.fn(function* (client, projectId, props) {
+// Only project/branch/app reads and the app create flow through the
+// provisioning-consistency retries, so a NotFound there is exactly the
+// post-create lag the schedule exists to absorb.
+// The retried effects mix distilled's tagged operation errors with plain
+// `Error` failures of their own (an unresolvable branch, a foreign App), so
+// narrow before reading the tag.
+const isAppProvisioningNotFound = (error) => "_tag" in error && error._tag === "NotFound";
+// Distilled emits the cursor-paginated list operations as plain ops, so
+// callers walk `pagination` themselves (see `src/Neon/Project.ts`).
+const listBranches = (projectId, gitName) => Effect.gen(function* () {
+    const branches = [];
+    let cursor;
+    while (true) {
+        const page = yield* getProjectBranches({
+            projectId,
+            limit: 100,
+            ...(gitName === undefined ? {} : { gitName }),
+            ...(cursor === undefined ? {} : { cursor }),
+        });
+        branches.push(...page.data);
+        const nextCursor = page.pagination.nextCursor;
+        if (!page.pagination.hasMore)
+            break;
+        if (nextCursor === null) {
+            return yield* Effect.fail(new PrismaPaginationError({
+                message: "Invalid Prisma Management API pagination response from getProjectBranches: hasMore was true without a non-empty nextCursor",
+            }));
+        }
+        cursor = nextCursor;
+    }
+    return branches;
+});
+const listApps = (projectId) => Effect.gen(function* () {
+    const apps = [];
+    let cursor;
+    while (true) {
+        const page = yield* getServices(cursor === undefined
+            ? { projectId, limit: 100 }
+            : { projectId, limit: 100, cursor });
+        apps.push(...page.data);
+        const nextCursor = page.pagination.nextCursor;
+        if (!page.pagination.hasMore)
+            break;
+        if (nextCursor === null) {
+            return yield* Effect.fail(new PrismaPaginationError({
+                message: "Invalid Prisma Management API pagination response from getServices: hasMore was true without a non-empty nextCursor",
+            }));
+        }
+        cursor = nextCursor;
+    }
+    return apps;
+});
+const desiredComputeBranchId = Effect.fn(function* (projectId, props) {
     if (props.branchId !== undefined && !isPrismaDevId(props.branchId)) {
         return { resolved: true, id: props.branchId };
     }
-    const branches = yield* client.listBranches(projectId, props.branchGitName === undefined
-        ? { limit: 100 }
-        : { gitName: props.branchGitName, limit: 100 });
+    const branches = yield* listBranches(projectId, props.branchGitName);
     const matchingBranches = props.branchGitName === undefined
         ? branches.filter((branch) => branch.isDefault)
         : branches;
@@ -331,14 +376,11 @@ const desiredComputeBranchId = Effect.fn(function* (client, projectId, props) {
         : { resolved: false };
 });
 const createAppName = (id, appName) => appName === undefined ? createPhysicalName({ id }) : Effect.succeed(appName);
-const findApp = Effect.fn(function* (client, projectId, appName, props) {
-    const candidates = (yield* client.listApps({
-        projectId,
-        limit: 100,
-    })).filter((app) => app.name === appName);
+const findApp = Effect.fn(function* (projectId, appName, props) {
+    const candidates = (yield* listApps(projectId)).filter((app) => app.name === appName);
     if (candidates.length === 0)
         return undefined;
-    const branch = yield* desiredComputeBranchId(client, projectId, props);
+    const branch = yield* desiredComputeBranchId(projectId, props);
     if (!branch.resolved)
         return undefined;
     const matches = candidates.filter((app) => app.branchId === branch.id);
@@ -347,13 +389,15 @@ const findApp = Effect.fn(function* (client, projectId, appName, props) {
     }
     return matches[0];
 });
-const createApp = (client, projectId, props, branchId) => client.createApp({
+const createApp = (projectId, props, branchId) => createService({
     projectId,
     displayName: props.appName,
-    regionId: props.regionId,
     branchId,
-    branchGitName: undefined,
-});
+    ...(props.regionId === undefined ? {} : { regionId: props.regionId }),
+}).pipe(
+// A replayed create would make a second App; the retry policy cannot
+// see the request, so opt out explicitly.
+Retry.none, Effect.map((response) => response.data));
 const plainEnv = (env = {}) => Object.fromEntries(Object.entries(env).flatMap(([key, value]) => value === undefined
     ? []
     : [[key, Redacted.isRedacted(value) ? Redacted.value(value) : value]]));
@@ -593,6 +637,10 @@ const isAutoBuild = (build) => build === "auto" ||
         build !== null &&
         "type" in build &&
         build.type === "auto");
+const isStaticBuild = (build) => typeof build === "object" &&
+    build !== null &&
+    "type" in build &&
+    build.type === "static";
 const readPackageMain = Effect.fn(function* (directory) {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
@@ -783,6 +831,40 @@ const resolveArtifact = Effect.fn(function* (props) {
             directory: artifact.directory,
             entrypoint: artifact.entrypoint,
             ignore: props.archiveIgnore,
+            ignorePrefix: artifact.archiveIgnorePrefix,
+            requiredFiles: artifact.requiredFiles,
+            output: "file",
+        }).pipe(Effect.ensuring(artifact.cleanup));
+        port = props.port ?? artifact.defaultPort ?? 8080;
+        return {
+            file,
+            hash: yield* sha256Object({
+                artifact: file.sha256,
+                env,
+                envClass,
+                port,
+            }),
+            port,
+        };
+    }
+    if (isStaticBuild(props.build)) {
+        const artifact = yield* runComputeStaticBuild({
+            appPath,
+            command: props.build.command,
+            cwd: props.build.cwd,
+            outdir: props.build.outdir,
+            indexPage: props.build.indexPage,
+            spa: props.build.spa,
+            env: props.build.env,
+            outputLimitBytes: props.build.outputLimitBytes,
+            timeoutSeconds: props.build.timeoutSeconds,
+        });
+        const file = yield* createComputeArchive({
+            directory: artifact.directory,
+            entrypoint: artifact.entrypoint,
+            ignore: props.archiveIgnore,
+            ignorePrefix: artifact.archiveIgnorePrefix,
+            requiredFiles: artifact.requiredFiles,
             output: "file",
         }).pipe(Effect.ensuring(artifact.cleanup));
         port = props.port ?? artifact.defaultPort ?? 8080;
@@ -831,17 +913,15 @@ const resolveArtifact = Effect.fn(function* (props) {
         port,
     };
 });
-const findExistingApp = Effect.fn(function* (client, output) {
+const findExistingApp = Effect.fn(function* (output) {
     const appId = output?.appId && !isPrismaDevId(output.appId) ? output.appId : undefined;
     return appId
-        ? yield* client
-            .getApp(appId)
-            .pipe(Effect.catchIf(isNotFound, () => Effect.succeed(undefined)))
+        ? yield* getService({ serviceId: appId }).pipe(Effect.map((response) => response.data), Effect.catchTag("NotFound", () => Effect.succeed(undefined)))
         : undefined;
 });
-const ensureApp = Effect.fn(function* (client, projectId, props, output, observedApp) {
-    let app = observedApp ?? (yield* findExistingApp(client, output));
-    const branch = yield* desiredComputeBranchId(client, projectId, props);
+const ensureApp = Effect.fn(function* (projectId, props, output, observedApp) {
+    let app = observedApp ?? (yield* findExistingApp(output));
+    const branch = yield* desiredComputeBranchId(projectId, props);
     if (!branch.resolved) {
         return yield* Effect.fail(new Error(props.branchGitName === undefined
             ? `Prisma project '${projectId}' has no default branch to attach Compute App '${props.appName}'. Create or promote a default branch, or specify branchId/branchGitName.`
@@ -849,7 +929,7 @@ const ensureApp = Effect.fn(function* (client, projectId, props, output, observe
     }
     let createdApp = false;
     if (!app) {
-        const result = yield* createApp(client, projectId, props, branch.id).pipe(Effect.map((app) => ({ app, created: true })), Effect.catchIf(isConflict, (conflict) => findApp(client, projectId, props.appName, props).pipe(Effect.flatMap((app) => app && output?.appId !== undefined && app.id === output.appId
+        const result = yield* createApp(projectId, props, branch.id).pipe(Effect.map((app) => ({ app, created: true })), Effect.catchTag("Conflict", (conflict) => findApp(projectId, props.appName, props).pipe(Effect.flatMap((app) => app && output?.appId !== undefined && app.id === output.appId
             ? Effect.succeed({ app, created: false })
             : Effect.fail(new Error(`Prisma App '${props.appName}' already exists on the requested branch but is not owned by this Compute resource. Import it with explicit adoption or choose a different App name.`, { cause: conflict }))))));
         app = result.app;
@@ -857,11 +937,11 @@ const ensureApp = Effect.fn(function* (client, projectId, props, output, observe
     }
     yield* ensureAppImmutableIdentity(app, projectId, props.regionId ?? output?.regionId ?? app.region.id);
     if (app.name !== props.appName || app.branchId !== branch.id) {
-        app = yield* client.updateApp(app.id, {
+        app = yield* updateService({
+            serviceId: app.id,
             displayName: props.appName,
             branchId: branch.id,
-            branchGitName: undefined,
-        });
+        }).pipe(Effect.map((response) => response.data));
     }
     return { app, created: createdApp };
 });
@@ -872,15 +952,33 @@ const ensureSkipCodeUploadCanFork = (props, app) => Effect.gen(function* () {
         return;
     return yield* Effect.fail(new Error("skipCodeUpload requires an existing Prisma deployment to fork from. Upload and start a deployment first, or remove skipCodeUpload."));
 });
-const findEnvironmentVariable = (client, projectId, cls, key, branchId) => client
-    .listEnvironmentVariables({
-    projectId,
-    class: cls,
-    key,
-    ...(branchId ? { branchId } : {}),
-    limit: 100,
-})
-    .pipe(Effect.map((variables) => variables.find((variable) => variable.branchId === (branchId ?? null))));
+const findEnvironmentVariable = (projectId, cls, key, branchId) => Effect.gen(function* () {
+    // Distilled emits the cursor-paginated list operations as plain ops, so
+    // callers walk `pagination` themselves (see `src/Neon/Project.ts`).
+    const variables = [];
+    let cursor;
+    while (true) {
+        const page = yield* getEnvironmentVariables({
+            projectId,
+            class: cls,
+            key,
+            limit: 100,
+            ...(branchId ? { branchId } : {}),
+            ...(cursor === undefined ? {} : { cursor }),
+        });
+        variables.push(...page.data);
+        const nextCursor = page.pagination.nextCursor;
+        if (!page.pagination.hasMore)
+            break;
+        if (nextCursor === null) {
+            return yield* Effect.fail(new PrismaPaginationError({
+                message: "Invalid Prisma Management API pagination response from getEnvironmentVariables: hasMore was true without a non-empty nextCursor",
+            }));
+        }
+        cursor = nextCursor;
+    }
+    return variables.find((variable) => variable.branchId === (branchId ?? null));
+});
 const systemManagedEnvironmentVariableError = (key) => new Error(`Prisma environment variable '${key}' is managed by Prisma and cannot be managed by Alchemy.`);
 const ensureUserManagedEnvironmentVariable = (variable) => Effect.gen(function* () {
     if (variable.isManagedBySystem) {
@@ -893,26 +991,26 @@ const environmentScope = (cls, branchId) => ({
     branchId: branchId ?? null,
 });
 const sameEnvironmentScope = (left, right) => left.class === right.class && left.branchId === right.branchId;
-const resolveComputeEnvironmentScope = Effect.fn(function* (client, app, props) {
+const resolveComputeEnvironmentScope = Effect.fn(function* (app, props) {
     if (!app.branchId) {
         return yield* Effect.fail(new Error("Prisma.Compute requires an attached branch because deployment creation resolves environment variables from the App branch."));
     }
-    const branch = yield* client.getBranch(app.branchId);
+    const branch = yield* getBranch({
+        branchId: app.branchId,
+    }).pipe(Effect.map((response) => response.data));
     const inferredClass = branch.role;
     if (props.envClass !== undefined && props.envClass !== inferredClass) {
         return yield* Effect.fail(new Error(`Prisma.Compute envClass '${props.envClass}' does not match attached branch role '${inferredClass}'. Omit envClass to let Alchemy infer the correct environment variable scope.`));
     }
     return environmentScope(inferredClass, inferredClass === "preview" ? app.branchId : null);
 });
-const rollbackCreatedEnvironmentVariables = Effect.fn(function* (client, createdIds, originalError) {
+const rollbackCreatedEnvironmentVariables = Effect.fn(function* (createdIds, originalError) {
     if (createdIds.length === 0) {
         return yield* Effect.fail(originalError);
     }
     const cleanupErrors = [];
     for (const created of [...createdIds].reverse()) {
-        const result = yield* Effect.result(client
-            .deleteEnvironmentVariable(created.id)
-            .pipe(Effect.catchIf(isNotFound, () => Effect.void)));
+        const result = yield* Effect.result(deleteEnvironmentVariable({ envVarId: created.id }).pipe(Effect.catchTag("NotFound", () => Effect.void)));
         if (Result.isFailure(result)) {
             cleanupErrors.push(result.failure);
         }
@@ -922,7 +1020,7 @@ const rollbackCreatedEnvironmentVariables = Effect.fn(function* (client, created
     }
     return yield* Effect.fail(originalError);
 });
-const syncComputeEnvironmentInternal = Effect.fn(function* (client, projectId, cls, env = {}, branchId, ownedIds = {}) {
+const syncComputeEnvironmentInternal = Effect.fn(function* (projectId, cls, env = {}, branchId, ownedIds = {}) {
     const synced = [];
     const deleted = [];
     const nextOwnedIds = {};
@@ -938,7 +1036,7 @@ const syncComputeEnvironmentInternal = Effect.fn(function* (client, projectId, c
         else {
             yield* validateComputeEnvironmentWrite(key, value);
         }
-        const variable = yield* findEnvironmentVariable(client, projectId, cls, key, branchId);
+        const variable = yield* findEnvironmentVariable(projectId, cls, key, branchId);
         if (variable) {
             yield* ensureUserManagedEnvironmentVariable(variable);
             if (ownedIds[key] !== variable.id) {
@@ -952,17 +1050,23 @@ const syncComputeEnvironmentInternal = Effect.fn(function* (client, projectId, c
             if (value === null)
                 continue;
             if (variable) {
-                yield* client.updateEnvironmentVariable(variable.id, { value });
+                yield* updateEnvironmentVariable({
+                    envVarId: variable.id,
+                    value,
+                });
                 nextOwnedIds[key] = variable.id;
             }
             else {
-                const created = yield* client.createEnvironmentVariable({
+                const created = yield* createEnvironmentVariable({
                     projectId,
                     ...(branchId ? { branchId } : {}),
                     class: cls,
                     key,
                     value,
-                });
+                }).pipe(
+                // A replayed create would make a second variable; the retry policy
+                // cannot see the request, so opt out explicitly.
+                Retry.none, Effect.map((response) => response.data));
                 createdIds.push({ key, id: created.id });
                 nextOwnedIds[key] = created.id;
             }
@@ -972,52 +1076,52 @@ const syncComputeEnvironmentInternal = Effect.fn(function* (client, projectId, c
         for (const { key, value, variable } of plans) {
             if (value !== null || !variable)
                 continue;
-            yield* client
-                .deleteEnvironmentVariable(variable.id)
-                .pipe(Effect.catchIf(isNotFound, () => Effect.void));
+            yield* deleteEnvironmentVariable({
+                envVarId: variable.id,
+            }).pipe(Effect.catchTag("NotFound", () => Effect.void));
             deleted.push(key);
         }
         return { synced, deleted, ownedIds: nextOwnedIds, createdIds };
     });
-    return yield* apply.pipe(Effect.catch((error) => rollbackCreatedEnvironmentVariables(client, createdIds, error)));
+    return yield* apply.pipe(Effect.catch((error) => rollbackCreatedEnvironmentVariables(createdIds, error)));
 });
-export const syncComputeEnvironment = Effect.fn(function* (client, projectId, cls, env = {}, branchId, ownedIds = {}) {
-    const result = yield* syncComputeEnvironmentInternal(client, projectId, cls, env, branchId, ownedIds);
+export const syncComputeEnvironment = Effect.fn(function* (projectId, cls, env = {}, branchId, ownedIds = {}) {
+    const result = yield* syncComputeEnvironmentInternal(projectId, cls, env, branchId, ownedIds);
     return {
         synced: result.synced,
         deleted: result.deleted,
         ownedIds: result.ownedIds,
     };
 });
-const destroyComputeEnvironment = Effect.fn(function* (client, projectId, scope, ownedIds = {}) {
+const destroyComputeEnvironment = Effect.fn(function* (projectId, scope, ownedIds = {}) {
     const deleted = [];
     for (const [key, ownedId] of Object.entries(ownedIds)) {
-        const variable = yield* findEnvironmentVariable(client, projectId, scope.class, key, scope.branchId).pipe(Effect.catchIf(isNotFound, () => Effect.succeed(undefined)));
+        const variable = yield* findEnvironmentVariable(projectId, scope.class, key, scope.branchId).pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
         if (!variable)
             continue;
         if (variable.id !== ownedId || variable.isManagedBySystem)
             continue;
-        yield* client
-            .deleteEnvironmentVariable(variable.id)
-            .pipe(Effect.catchIf(isNotFound, () => Effect.void));
+        yield* deleteEnvironmentVariable({
+            envVarId: variable.id,
+        }).pipe(Effect.catchTag("NotFound", () => Effect.void));
         deleted.push(key);
     }
     return { deleted };
 });
-const cleanupRemovedComputeEnvironment = Effect.fn(function* (client, projectId, oldScope, oldOwnedIds, newScope, newEnv) {
+const cleanupRemovedComputeEnvironment = Effect.fn(function* (projectId, oldScope, oldOwnedIds, newScope, newEnv) {
     const newValues = plainEnv(newEnv);
     const deleted = [];
     for (const [key, ownedId] of Object.entries(oldOwnedIds)) {
         if (sameEnvironmentScope(oldScope, newScope) && key in newValues)
             continue;
-        const variable = yield* findEnvironmentVariable(client, projectId, oldScope.class, key, oldScope.branchId);
+        const variable = yield* findEnvironmentVariable(projectId, oldScope.class, key, oldScope.branchId);
         if (!variable)
             continue;
         if (variable.id !== ownedId || variable.isManagedBySystem)
             continue;
-        yield* client
-            .deleteEnvironmentVariable(variable.id)
-            .pipe(Effect.catchIf(isNotFound, () => Effect.void));
+        yield* deleteEnvironmentVariable({
+            envVarId: variable.id,
+        }).pipe(Effect.catchTag("NotFound", () => Effect.void));
         deleted.push(key);
     }
     return { deleted };
@@ -1060,7 +1164,6 @@ const activeBindingEnv = (bindings) => bindings
     .map((binding) => binding.data?.env)
     .reduce((acc, env) => (env ? { ...acc, ...env } : acc), {});
 const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
-    const client = yield* PrismaClient;
     return {
         stables: ["appId"],
         // Compute is a composite over App + Deployment. AppProvider owns nuke
@@ -1099,23 +1202,21 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                 ? output.appId
                 : undefined;
             const app = appId
-                ? yield* client
-                    .getApp(appId)
-                    .pipe(Effect.catchIf(isNotFound, () => Effect.succeed(undefined)))
+                ? yield* getService({ serviceId: appId }).pipe(Effect.map((response) => response.data), Effect.catchTag("NotFound", () => Effect.succeed(undefined)))
                 : yield* Effect.gen(function* () {
                     const projectId = unresolvedProjectIdOf(olds.project);
                     return projectId
-                        ? yield* findApp(client, projectId, yield* createAppName(id, olds.appName), olds)
+                        ? yield* findApp(projectId, yield* createAppName(id, olds.appName), olds)
                         : undefined;
                 });
             if (!app)
                 return undefined;
-            const readDeployment = (id) => observeDeployment(client, id).pipe(Effect.catchIf(isNotFound, () => Effect.succeed(undefined)));
+            const readDeployment = (id) => observeDeployment(id).pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
             const outputDeployment = output?.deploymentId
                 ? yield* readDeployment(output.deploymentId)
                 : undefined;
             if (outputDeployment) {
-                yield* ensureDeploymentMembership(client, app.id, outputDeployment, app.latestDeploymentId);
+                yield* ensureDeploymentMembership(app.id, outputDeployment, app.latestDeploymentId);
             }
             const latestDeployment = !outputDeployment && app.latestDeploymentId
                 ? yield* readDeployment(app.latestDeploymentId)
@@ -1167,25 +1268,25 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
             const cleanupArtifact = artifact.file?.cleanup ?? Effect.void;
             const releaseArtifactOnFailure = (effect) => effect.pipe(Effect.onExit((exit) => Exit.isSuccess(exit) ? Effect.void : cleanupArtifact));
             const observedApp = effectiveNews.skipCodeUpload
-                ? yield* releaseArtifactOnFailure(findExistingApp(client, output).pipe(Effect.retry({
+                ? yield* releaseArtifactOnFailure(findExistingApp(output).pipe(Effect.retry({
                     while: isAppProvisioningNotFound,
                     schedule: projectConsistencySchedule,
                 })))
                 : undefined;
             yield* releaseArtifactOnFailure(ensureSkipCodeUploadCanFork(effectiveNews, observedApp));
-            const ensuredApp = yield* releaseArtifactOnFailure(ensureApp(client, projectId, effectiveNews, output, observedApp).pipe(Effect.retry({
+            const ensuredApp = yield* releaseArtifactOnFailure(ensureApp(projectId, effectiveNews, output, observedApp).pipe(Effect.retry({
                 while: isAppProvisioningNotFound,
                 schedule: projectConsistencySchedule,
             })));
             let app = ensuredApp.app;
             let preserveCreatedAppOnFailure = false;
             const cleanupCreatedAppOnFailure = (error) => ensuredApp.created && !preserveCreatedAppOnFailure
-                ? destroyApp(client, app.id).pipe(Effect.catch((cleanupError) => Effect.fail(aggregateCleanupFailure("App", app.id, `/v1/apps/${app.id}`, error, cleanupError))), Effect.andThen(() => Effect.fail(error)))
+                ? destroyApp(app.id).pipe(Effect.catch((cleanupError) => Effect.fail(aggregateCleanupFailure("App", app.id, `/v1/services/${app.id}`, error, cleanupError))), Effect.andThen(() => Effect.fail(error)))
                 : Effect.fail(error);
             let createdEnvironmentVariableIds = [];
             let deploymentConverged = false;
             return yield* Effect.gen(function* () {
-                const currentEnvironmentScope = yield* resolveComputeEnvironmentScope(client, app, effectiveNews);
+                const currentEnvironmentScope = yield* resolveComputeEnvironmentScope(app, effectiveNews);
                 const deploymentHash = yield* sha256Object({
                     artifact: artifact.hash,
                     branchId: app.branchId,
@@ -1194,7 +1295,7 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                 });
                 const outputArtifactHash = persistedArtifactHashValue(output?.artifactHash);
                 const persistedDeployment = output?.deploymentId
-                    ? yield* observeDeployment(client, output.deploymentId).pipe(Effect.catchIf(isNotFound, () => Effect.succeed(undefined)))
+                    ? yield* observeDeployment(output.deploymentId).pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)))
                     : undefined;
                 const terminalFailedDeploymentId = persistedDeployment?.status === "failed"
                     ? persistedDeployment.id
@@ -1202,17 +1303,17 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                 const promotionRequested = !(effectiveNews.skipPromote ?? false);
                 let persistedPendingCleanup = output?.pendingDeploymentCleanup;
                 const cleanupPreviousDeployment = Effect.fn(function* (deploymentId, action) {
-                    const observed = yield* observeDeployment(client, deploymentId).pipe(Effect.catchIf(isNotFound, () => Effect.succeed(undefined)));
+                    const observed = yield* observeDeployment(deploymentId).pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
                     if (!observed) {
                         return (action === "destroy" ? "destroyed" : "stopped");
                     }
-                    yield* ensureDeploymentMembership(client, app.id, observed, app.latestDeploymentId);
+                    yield* ensureDeploymentMembership(app.id, observed, app.latestDeploymentId);
                     if (action === "destroy") {
-                        yield* destroyDeployment(client, deploymentId, effectiveNews);
+                        yield* destroyDeployment(deploymentId, effectiveNews);
                         return "destroyed";
                     }
-                    yield* stopDeploymentIdempotent(client, deploymentId).pipe(Effect.catchIf(isNotFound, () => Effect.void));
-                    yield* waitForDeploymentStatus(client, deploymentId, "stopped", effectiveNews).pipe(Effect.catchIf(isNotFound, () => Effect.succeed(undefined)));
+                    yield* stopDeploymentIdempotent(deploymentId).pipe(Effect.catchTag("NotFound", () => Effect.void));
+                    yield* waitForDeploymentStatus(deploymentId, "stopped", effectiveNews).pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
                     return "stopped";
                 });
                 if (terminalFailedDeploymentId !== undefined &&
@@ -1238,22 +1339,21 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                     app.latestDeploymentId !== output.deploymentId) {
                     const persistedDeploymentId = output.deploymentId;
                     const displacedDeploymentId = app.latestDeploymentId;
-                    const rollback = yield* client
-                        .rollbackApp(app.id, {
+                    const rollback = yield* createServiceRollback({
+                        serviceId: app.id,
                         deploymentId: persistedDeploymentId,
-                    })
-                        .pipe(Effect.result);
-                    const observedAfterRollback = yield* waitForAppDeploymentTarget(client, app.id, persistedDeploymentId, effectiveNews).pipe(Effect.result);
+                    }).pipe(Effect.map((response) => response.data), Effect.result);
+                    const observedAfterRollback = yield* waitForAppDeploymentTarget(app.id, persistedDeploymentId, effectiveNews).pipe(Effect.result);
                     if (Result.isFailure(observedAfterRollback)) {
                         return yield* Effect.fail(new AggregateError([
                             ...(Result.isFailure(rollback) ? [rollback.failure] : []),
                             ...(Result.isFailure(observedAfterRollback)
                                 ? [observedAfterRollback.failure]
                                 : []),
-                        ], `Prisma App '${app.id}' has live deployment '${displacedDeploymentId}', while Alchemy state preserves deployment '${persistedDeploymentId}' as the prior promoted generation. Recovery via POST /v1/apps/${app.id}/rollback did not converge, so no environment variables or new deployment were changed and neither deployment was deleted.`));
+                        ], `Prisma App '${app.id}' has live deployment '${displacedDeploymentId}', while Alchemy state preserves deployment '${persistedDeploymentId}' as the prior promoted generation. Recovery via POST /v1/services/${app.id}/rollback did not converge, so no environment variables or new deployment were changed and neither deployment was deleted.`));
                     }
                     app = observedAfterRollback.success;
-                    yield* destroyDeployment(client, displacedDeploymentId, effectiveNews).pipe(Effect.catch((cleanupError) => Effect.fail(new AggregateError([
+                    yield* destroyDeployment(displacedDeploymentId, effectiveNews).pipe(Effect.catch((cleanupError) => Effect.fail(new AggregateError([
                         ...(Result.isFailure(rollback)
                             ? [rollback.failure]
                             : []),
@@ -1278,7 +1378,7 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                 }
                 const previousEnvironmentScope = environmentScope(olds?.envClass ?? output?.environmentClass ?? "production", output?.environmentBranchId);
                 const previousEnvironmentVariableIds = output?.environmentVariableIds ?? {};
-                const environmentResult = yield* syncComputeEnvironmentInternal(client, projectId, currentEnvironmentScope.class, effectiveNews.env, currentEnvironmentScope.branchId, sameEnvironmentScope(previousEnvironmentScope, currentEnvironmentScope)
+                const environmentResult = yield* syncComputeEnvironmentInternal(projectId, currentEnvironmentScope.class, effectiveNews.env, currentEnvironmentScope.branchId, sameEnvironmentScope(previousEnvironmentScope, currentEnvironmentScope)
                     ? previousEnvironmentVariableIds
                     : {});
                 createdEnvironmentVariableIds = environmentResult.createdIds;
@@ -1286,7 +1386,7 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                 // formerly-owned keys before creating it so deleted keys cannot be
                 // captured into the new runtime. Any failure here happens before
                 // deployment creation and rolls back newly-created variables.
-                yield* cleanupRemovedComputeEnvironment(client, projectId, previousEnvironmentScope, previousEnvironmentVariableIds, currentEnvironmentScope, effectiveNews.env);
+                yield* cleanupRemovedComputeEnvironment(projectId, previousEnvironmentScope, previousEnvironmentVariableIds, currentEnvironmentScope, effectiveNews.env);
                 let deployment = outputArtifactHash === deploymentHash
                     ? persistedDeployment
                     : undefined;
@@ -1298,20 +1398,26 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                 if (persistedDeployment !== undefined &&
                     (deployment !== undefined ||
                         terminalFailedDeploymentId !== undefined)) {
-                    yield* ensureDeploymentMembership(client, app.id, persistedDeployment, app.latestDeploymentId);
+                    yield* ensureDeploymentMembership(app.id, persistedDeployment, app.latestDeploymentId);
                 }
                 if (terminalFailedDeploymentId !== undefined) {
                     deployment = undefined;
                 }
                 let createdDeploymentId;
                 const cleanupCreatedDeploymentOnFailure = (failedDeploymentId, error) => createdDeploymentId === failedDeploymentId
-                    ? destroyDeployment(client, failedDeploymentId, effectiveNews).pipe(Effect.catch((cleanupError) => Effect.fail(aggregateCleanupFailure("deployment", failedDeploymentId, `/v1/deployments/${failedDeploymentId}`, error, cleanupError))), Effect.andThen(() => Effect.fail(error)))
+                    ? destroyDeployment(failedDeploymentId, effectiveNews).pipe(Effect.catch((cleanupError) => Effect.fail(aggregateCleanupFailure("deployment", failedDeploymentId, `/v1/deployments/${failedDeploymentId}`, error, cleanupError))), Effect.andThen(() => Effect.fail(error)))
                     : Effect.fail(error);
                 if (!deployment) {
-                    const created = yield* client.createAppDeployment(app.id, {
+                    const created = yield* createServiceDeployment({
+                        serviceId: app.id,
                         portMapping: { http: artifact.port },
-                        skipCodeUpload: effectiveNews.skipCodeUpload,
-                    });
+                        ...(effectiveNews.skipCodeUpload === undefined
+                            ? {}
+                            : { skipCodeUpload: effectiveNews.skipCodeUpload }),
+                    }).pipe(
+                    // A replayed create would make a second deployment; the retry
+                    // policy cannot see the request, so opt out explicitly.
+                    Retry.none, Effect.map((response) => response.data));
                     createdDeploymentId = created.id;
                     if (artifact.file !== undefined && !created.uploadUrl) {
                         return yield* cleanupCreatedDeploymentOnFailure(created.id, new Error("Prisma deployment creation did not return an upload URL."));
@@ -1319,10 +1425,8 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                     if (created.uploadUrl && artifact.file !== undefined) {
                         yield* uploadArtifact(created.uploadUrl, artifact.file, "application/gzip").pipe(Effect.catch((error) => cleanupCreatedDeploymentOnFailure(created.id, error)));
                     }
-                    deployment = yield* observeDeployment(client, created.id).pipe(Effect.catchIf(isNotFound, () => Effect.succeed({
+                    deployment = yield* observeDeployment(created.id).pipe(Effect.catchTag("NotFound", () => Effect.succeed({
                         id: created.id,
-                        type: "deployment",
-                        url: created.url,
                         foundryVersionId: created.foundryVersionId,
                         status: "new",
                         previewDomain: null,
@@ -1347,9 +1451,9 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                     deployment = yield* Effect.gen(function* () {
                         if (currentDeployment.status !== "running" &&
                             currentDeployment.status !== "provisioning") {
-                            yield* startDeploymentIdempotent(client, currentDeployment.id);
+                            yield* startDeploymentIdempotent(currentDeployment.id);
                         }
-                        const running = yield* waitForDeploymentStatus(client, currentDeployment.id, "running", effectiveNews);
+                        const running = yield* waitForDeploymentStatus(currentDeployment.id, "running", effectiveNews);
                         yield* waitForDeploymentUrl(toDeploymentUrl(running.previewDomain), effectiveNews);
                         return running;
                     }).pipe(Effect.catch((error) => cleanupCreatedDeploymentOnFailure(currentDeploymentId, error)));
@@ -1361,7 +1465,7 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                     // Replay promotion even when latestDeploymentId already matches.
                     // Promotion also repairs endpoint/custom-domain routing drift.
                     preserveCreatedAppOnFailure = true;
-                    const promotedApp = yield* promoteAppObserved(client, app.id, deployment.id, effectiveNews);
+                    const promotedApp = yield* promoteAppObserved(app.id, deployment.id, effectiveNews);
                     appEndpointDomain = promotedApp.appEndpointDomain;
                     promoted = true;
                 }
@@ -1375,12 +1479,11 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                         readinessStatus = "ready";
                     }
                     else if (rollbackDeploymentId) {
-                        const rollback = yield* client
-                            .rollbackApp(app.id, {
+                        const rollback = yield* createServiceRollback({
+                            serviceId: app.id,
                             deploymentId: rollbackDeploymentId,
-                        })
-                            .pipe(Effect.result);
-                        const observedAfterRollback = yield* waitForAppDeploymentTarget(client, app.id, rollbackDeploymentId, effectiveNews).pipe(Effect.result);
+                        }).pipe(Effect.map((response) => response.data), Effect.result);
+                        const observedAfterRollback = yield* waitForAppDeploymentTarget(app.id, rollbackDeploymentId, effectiveNews).pipe(Effect.result);
                         if (Result.isSuccess(observedAfterRollback)) {
                             return yield* cleanupCreatedDeploymentOnFailure(deployment.id, Result.isSuccess(rollback)
                                 ? readiness.failure
@@ -1390,7 +1493,7 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                             readiness.failure,
                             ...(Result.isFailure(rollback) ? [rollback.failure] : []),
                             observedAfterRollback.failure,
-                        ], `Prisma App '${app.id}' promoted deployment '${deployment.id}', but its stable endpoint failed readiness and rollback to deployment '${rollbackDeploymentId}' did not converge. Alchemy preserved the prior deployment in state and deleted neither deployment; the next reconcile will retry recovery via POST /v1/apps/${app.id}/rollback before making any new cloud changes.`));
+                        ], `Prisma App '${app.id}' promoted deployment '${deployment.id}', but its stable endpoint failed readiness and rollback to deployment '${rollbackDeploymentId}' did not converge. Alchemy preserved the prior deployment in state and deleted neither deployment; the next reconcile will retry recovery via POST /v1/services/${app.id}/rollback before making any new cloud changes.`));
                     }
                     else {
                         // A first deployment has no safe rollback target. Never report
@@ -1459,18 +1562,18 @@ const ProviderLive = () => Provider.effect(Compute, Effect.gen(function* () {
                 };
             }).pipe(Effect.catch((error) => deploymentConverged
                 ? Effect.fail(error)
-                : rollbackCreatedEnvironmentVariables(client, createdEnvironmentVariableIds, error)), Effect.catch(cleanupCreatedAppOnFailure), Effect.ensuring(cleanupArtifact));
+                : rollbackCreatedEnvironmentVariables(createdEnvironmentVariableIds, error)), Effect.catch(cleanupCreatedAppOnFailure), Effect.ensuring(cleanupArtifact));
         }),
         delete: Effect.fn(function* ({ olds, output }) {
             if (output.local || isPrismaDevId(output.appId)) {
                 yield* stopTrackedDevProcess(output.appId);
                 return;
             }
-            yield* destroyComputeEnvironment(client, output.projectId, environmentScope(olds?.envClass ?? output.environmentClass ?? "production", output.environmentBranchId), output.environmentVariableIds);
-            yield* destroyApp(client, output.appId);
+            yield* destroyComputeEnvironment(output.projectId, environmentScope(olds?.envClass ?? output.environmentClass ?? "production", output.environmentBranchId), output.environmentVariableIds);
+            yield* destroyApp(output.appId);
         }),
         tail: ({ output }) => output.deploymentId
-            ? tailDeploymentLogs(client, output.deploymentId)
+            ? tailDeploymentLogs(output.deploymentId)
             : Stream.empty,
     };
 }));