alchemy 2.0.0-beta.36 → 2.0.0-beta.38

package/src/Cloudflare/Workers/Workflow.ts

@@ -50,12 +50,21 @@ export class WorkflowStep extends Context.Service<
  * Execute a named, durable workflow step. The effect is run inside the
  * Cloudflare step transaction so its result is automatically persisted
  * and replayed on retries.
+ *
+ * Any services the inner effect requires (e.g. `WorkerEnvironment` from a
+ * binding like `kv.put` / `kv.get`) are threaded through automatically by
+ * capturing the surrounding workflow body's context and providing it to
+ * the inner effect before it runs inside `step.do`.
  */
-export const task = <T>(
+export const task = <T, R = never>(
   name: string,
-  effect: Effect.Effect<T>,
-): Effect.Effect<T, never, WorkflowStep> =>
-  WorkflowStep.asEffect().pipe(Effect.flatMap((step) => step.do(name, effect)));
+  effect: Effect.Effect<T, never, R>,
+): Effect.Effect<T, never, WorkflowStep | R> =>
+  Effect.gen(function* () {
+    const step = yield* WorkflowStep;
+    const context = yield* Effect.context<R>();
+    return yield* step.do(name, effect.pipe(Effect.provide(context)));
+  });
 
 /**
  * Pause the workflow for the given duration.
@@ -64,7 +73,7 @@ export const sleep = (
   name: string,
   duration: string | number,
 ): Effect.Effect<void, never, WorkflowStep> =>
-  WorkflowStep.asEffect().pipe(
+  WorkflowStep.pipe(
     Effect.flatMap((step) => step.sleep(name, duration)),
     Effect.orDie,
   );
@@ -76,7 +85,7 @@ export const sleepUntil = (
   name: string,
   timestamp: Date | number,
 ): Effect.Effect<void, never, WorkflowStep> =>
-  WorkflowStep.asEffect().pipe(
+  WorkflowStep.pipe(
     Effect.flatMap((step) => step.sleepUntil(name, timestamp)),
     Effect.orDie,
   );
@@ -103,20 +112,17 @@ export type WorkflowServices = WorkerServices | PlatformServices;
  */
 export interface WorkflowExport {
   readonly kind: "workflow";
-  readonly make: (
-    env: unknown,
-  ) => Effect.Effect<Effect.Effect<unknown, never, WorkflowRunServices>>;
+  readonly make: (env: unknown) => Effect.Effect<WorkflowImpl<any, any>>;
 }
 
 /**
- * A workflow body is an Effect that requires WorkflowRunServices
- * (event + step) to execute.
+ * A workflow implementation is a function from a typed `Input` payload to
+ * an Effect that produces the workflow's `Result`. The Effect requires
+ * `WorkflowRunServices` (event + step + env) to execute.
  */
-export type WorkflowBody<Result = unknown> = Effect.Effect<
-  Result,
-  never,
-  WorkflowRunServices
->;
+export type WorkflowImpl<Input = unknown, Result = unknown> = (
+  input: Input,
+) => Effect.Effect<Result, never, WorkflowRunServices>;
 
 export const isWorkflowExport = (value: unknown): value is WorkflowExport =>
   typeof value === "object" &&
@@ -141,24 +147,24 @@ export const isWorkflowBinding = (binding: {
  * Handle returned to the caller at deploy/bind time. Allows starting
  * workflow instances and checking their status from the Api layer.
  */
-export interface WorkflowHandle<Params = unknown> {
+export interface WorkflowHandle<Input = unknown, Result = unknown> {
   Type: WorkflowTypeId;
   name: string;
-  create(params?: Params): Effect.Effect<WorkflowInstance>;
-  get(instanceId: string): Effect.Effect<WorkflowInstance>;
+  create(input: Input): Effect.Effect<WorkflowInstance<Result>>;
+  get(instanceId: string): Effect.Effect<WorkflowInstance<Result>>;
 }
 
-export interface WorkflowInstance {
+export interface WorkflowInstance<Result = unknown> {
   id: string;
-  status(): Effect.Effect<WorkflowInstanceStatus>;
+  status(): Effect.Effect<WorkflowInstanceStatus<Result>>;
   pause(): Effect.Effect<void>;
   resume(): Effect.Effect<void>;
   terminate(): Effect.Effect<void>;
 }
 
-export interface WorkflowInstanceStatus {
+export interface WorkflowInstanceStatus<Result = unknown> {
   status: string;
-  output?: unknown;
+  output?: Result;
   error?: { name: string; message: string } | null;
 }
 
@@ -168,22 +174,22 @@ export interface WorkflowClass extends Effect.Effect<
   WorkflowHandle
 > {
   <_Self>(): {
-    <Result = unknown, InitReq = never>(
+    <Input = unknown, Result = unknown, InitReq = never>(
       name: string,
-      impl: Effect.Effect<WorkflowBody<Result>, never, InitReq>,
+      impl: Effect.Effect<WorkflowImpl<Input, Result>, never, InitReq>,
     ): Effect.Effect<
-      WorkflowHandle,
+      WorkflowHandle<Input, Result>,
       never,
       Worker | Exclude<InitReq, WorkflowServices>
     > & {
-      new (_: never): WorkflowBody<Result>;
+      new (_: never): WorkflowImpl<Input, Result>;
     };
   };
-  <Result = unknown, InitReq = never>(
+  <Input = unknown, Result = unknown, InitReq = never>(
     name: string,
-    impl: Effect.Effect<WorkflowBody<Result>, never, InitReq>,
+    impl: Effect.Effect<WorkflowImpl<Input, Result>, never, InitReq>,
   ): Effect.Effect<
-    WorkflowHandle,
+    WorkflowHandle<Input, Result>,
     never,
     Worker | Exclude<InitReq, WorkflowServices>
   >;
@@ -200,18 +206,18 @@ export class WorkflowScope extends Context.Service<
  *
  * A Workflow follows the same two-phase pattern as Workers and Durable
  * Objects. The outer `Effect.gen` resolves shared dependencies. The inner
- * `Effect.gen` is the workflow body — it reads the triggering event and
- * runs steps using `task`, `sleep`, and `sleepUntil`.
+ * `Effect.fn` is the workflow body — a function from a typed `input`
+ * payload to an Effect that runs steps using `task`, `sleep`, and
+ * `sleepUntil`.
  *
  * ```typescript
  * Effect.gen(function* () {
  *   // Phase 1: resolve dependencies
  *   const notifier = yield* NotificationService;
  *
- *   return Effect.gen(function* () {
+ *   return Effect.fn(function* (input: { orderId: string }) {
  *     // Phase 2: workflow body (durable steps)
- *     const event = yield* Cloudflare.WorkflowEvent;
- *     const result = yield* Cloudflare.task("process", doWork(event.payload));
+ *     const result = yield* Cloudflare.task("process", doWork(input.orderId));
  *     yield* Cloudflare.sleep("cooldown", "10 seconds");
  *     return result;
  *   });
@@ -226,9 +232,8 @@ export class WorkflowScope extends Context.Service<
  * export default class MyWorkflow extends Cloudflare.Workflow<MyWorkflow>()(
  *   "MyWorkflow",
  *   Effect.gen(function* () {
- *     return Effect.gen(function* () {
- *       const event = yield* Cloudflare.WorkflowEvent;
- *       return { received: event.payload };
+ *     return Effect.fn(function* (input: { name: string }) {
+ *       return { received: input.name };
  *     });
  *   }),
  * ) {}
@@ -248,33 +253,31 @@ export class WorkflowScope extends Context.Service<
  * yield* Cloudflare.sleep("cooldown", "30 seconds");
  * ```
  *
- * @example Accessing env bindings inside a step
- * `Cloudflare.WorkerEnvironment` is the same service available
- * inside a Worker — it gives you typed access to env bindings (KV,
- * R2, etc.) from inside a workflow body. Wrap any side-effecting
- * call in `task` so the result is persisted across replays.
+ * @example Accessing env bindings inside a task
+ * Bind a resource (e.g. `KVNamespace`, `R2Bucket`) in the workflow's
+ * outer init phase to get a typed Effect-native client, then use it
+ * directly inside `task`. `task` threads the binding's service
+ * requirement (`WorkerEnvironment`) through automatically so the inner
+ * Effect needs no extra plumbing.
  *
  * ```typescript
  * Effect.gen(function* () {
- *   const env = yield* Cloudflare.WorkerEnvironment;
- *   const event = yield* Cloudflare.WorkflowEvent;
- *   const { roomId, message } = event.payload as {
- *     roomId: string;
- *     message: string;
- *   };
+ *   const kv = yield* Cloudflare.KVNamespace.bind(KV);
+ *
+ *   return Effect.fn(function* (input: { roomId: string; message: string }) {
+ *     const { roomId, message } = input;
  *
- *   const stored = yield* Cloudflare.task(
- *     "kv-roundtrip",
- *     Effect.tryPromise({
- *       try: async () => {
- *         await env.KV.put(`workflow:${roomId}`, message);
- *         return await env.KV.get(`workflow:${roomId}`);
- *       },
- *       catch: (cause) =>
- *         cause instanceof Error ? cause : new Error(String(cause)),
- *     }).pipe(Effect.orDie),
- *   );
- *   return stored;
+ *     const stored = yield* Cloudflare.task(
+ *       "kv-roundtrip",
+ *       Effect.gen(function* () {
+ *         const key = `workflow:${roomId}`;
+ *         yield* kv.put(key, message);
+ *         return yield* kv.get(key);
+ *       }).pipe(Effect.orDie),
+ *     );
+ *
+ *     return stored;
+ *   });
  * });
  * ```
  *
@@ -357,7 +360,7 @@ export class WorkflowScope extends Context.Service<
  * ```
  */
 export const Workflow: WorkflowClass = taggedFunction(WorkflowScope, ((
-  ...args: [] | [name: string, impl: Effect.Effect<WorkflowBody>]
+  ...args: [] | [name: string, impl: Effect.Effect<WorkflowImpl<any, any>>]
 ) =>
   args.length === 0
     ? Workflow
@@ -404,11 +407,11 @@ export const Workflow: WorkflowClass = taggedFunction(WorkflowScope, ((
             }),
           );
 
-          const self: WorkflowHandle = {
+          const self: WorkflowHandle<any, any> = {
             Type: WorkflowTypeId,
             name,
-            create: (params?: unknown) =>
-              Effect.tryPromise(() => binding.create({ params })).pipe(
+            create: (input: unknown) =>
+              Effect.tryPromise(() => binding.create({ params: input })).pipe(
                 Effect.map(wrapInstance),
                 Effect.orDie,
               ),
@@ -419,21 +422,22 @@ export const Workflow: WorkflowClass = taggedFunction(WorkflowScope, ((
               ),
           };
 
-          const body = yield* impl.pipe(
+          const fn = yield* impl.pipe(
             Effect.provideService(WorkflowScope, self as any),
           );
 
           yield* worker.export(name, {
             kind: "workflow",
             make: (env: unknown) =>
-              Effect.succeed(
-                body.pipe(
+              Effect.succeed(((input: unknown) =>
+                fn(input).pipe(
                   Effect.provideService(
                     WorkerEnvironment,
                     env as Record<string, any>,
                   ),
-                ),
-              ).pipe(Effect.provideContext(services)),
+                )) as WorkflowImpl<any, any>).pipe(
+                Effect.provideContext(services),
+              ),
           } satisfies WorkflowExport);
 
           return self;
@@ -520,13 +524,13 @@ export const WorkflowProvider = () =>
 // Helpers
 // ---------------------------------------------------------------------------
 
-const wrapInstance = (raw: any): WorkflowInstance => ({
+const wrapInstance = <Result>(raw: any): WorkflowInstance<Result> => ({
   id: raw.id,
   status: () =>
     Effect.tryPromise(() => raw.status()).pipe(
       Effect.map((s: any) => ({
         status: s.status as string,
-        output: s.output,
+        output: s.output as Result,
         error: s.error,
       })),
       Effect.orDie,

package/src/Cloudflare/Workers/index.ts

@@ -1,5 +1,6 @@
 export * from "./Assets.ts";
 export * from "./ConfigProvider.ts";
+export * from "./CronEventSource.ts";
 export * from "./DurableObjectNamespace.ts";
 export * from "./DurableObjectState.ts";
 export * from "./DurableObjectStorage.ts";

package/src/Cloudflare/index.ts

@@ -1,10 +1,12 @@
 export * from "./ApiToken/index.ts";
 export * from "./Artifacts/index.ts";
 export * from "./AiGateway/index.ts";
+export * from "./AnalyticsEngine/index.ts";
 export * from "./CloudflareEnvironment.ts";
 export * from "./Container/index.ts";
 export * from "./D1/index.ts";
 export * from "./EdgeSession.ts";
+export * from "./Email/index.ts";
 export * from "./Hyperdrive/index.ts";
 export * from "./Images/index.ts";
 export * from "./KV/index.ts";

package/src/Construct.ts

@@ -49,11 +49,7 @@ import * as Namespace from "./Namespace.ts";
  * ```
  */
 export const fn: {
-  <
-    Eff extends Effect.Yieldable<any, any, any, any>,
-    AEff,
-    Props extends object,
-  >(
+  <Eff extends Effect.Effect<any, any, any>, AEff, Props extends object>(
     body: (id: string, props: Props) => Generator<Eff, AEff, never>,
   ): (
     id: string,
@@ -62,12 +58,12 @@ export const fn: {
     AEff,
     [Eff] extends [never]
       ? never
-      : [Eff] extends [Effect.Yieldable<infer _S, infer _A, infer E, infer _R>]
+      : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>]
         ? E
         : never,
     [Eff] extends [never]
       ? never
-      : [Eff] extends [Effect.Yieldable<infer _S, infer _A, infer _E, infer R>]
+      : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>]
         ? R
         : never
   >;

package/src/Deploy.ts

@@ -1,4 +1,5 @@
 import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
 import { AlchemyContext } from "./AlchemyContext.ts";
 import * as Apply from "./Apply.ts";
 import type { Input } from "./Input.ts";
@@ -10,10 +11,13 @@ export const deploy = <A>({
   stack,
   stage,
   dev,
+  scope,
 }: {
   stack: StackEffect<CompiledStack<A>, Stage | AlchemyContext>;
   stage: string;
   dev?: boolean;
+  /** See {@link evalStack} — when set, scoped resources outlive `deploy`. */
+  scope?: Scope.Scope;
 }) =>
   evalStack(
     stack,
@@ -23,5 +27,5 @@ export const deploy = <A>({
         const output = yield* Apply.apply(plan);
         return output as Input.Resolve<A>;
       }),
-    { stage, dev },
+    { stage, dev, scope },
   );

package/src/Destroy.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect";
+import type * as Scope from "effect/Scope";
 import type { AlchemyContext } from "./AlchemyContext.ts";
 import * as Apply from "./Apply.ts";
 import * as Plan from "./Plan.ts";
@@ -10,10 +11,13 @@ export const destroy = ({
   stack,
   stage,
   dev,
+  scope,
 }: {
   stack: StackEffect<CompiledStack, Stage | AlchemyContext>;
   stage: string;
   dev?: boolean;
+  /** See {@link evalStack} — when set, scoped resources outlive `destroy`. */
+  scope?: Scope.Scope;
 }) =>
   evalStack(
     stack,
@@ -24,7 +28,8 @@ export const destroy = ({
         // TODO(sam): probably better to have Plan.destroy and Plan.update
         resources: {},
         bindings: {},
+        actions: {},
         output: {},
       }).pipe(Effect.flatMap(Apply.apply)),
-    { stage, dev },
+    { stage, dev, scope },
   );

package/src/Http.ts

@@ -80,7 +80,7 @@ export const safeHttpEffect = <Req = never>(
 export const resolvePort = (options: { port?: number } | undefined) =>
   options?.port !== undefined
     ? Effect.succeed(options.port)
-    : Config.number("PORT").pipe(Config.withDefault(3000)).asEffect();
+    : Config.number("PORT").pipe(Config.withDefault(3000));
 
 export const BunHttpServer = () =>
   Layer.effect(

package/src/Namespace.ts

@@ -40,10 +40,10 @@ export const set = (namespace: string | NamespaceNode) =>
   );
 
 export const CurrentNamespace = Effect.serviceOption(Namespace)
-  .asEffect()
+
   .pipe(Effect.map(Option.getOrUndefined));
 
-export const CurrentChain = CurrentNamespace.asEffect().pipe(
+export const CurrentChain = CurrentNamespace.pipe(
   Effect.map(function findRoot(ns): string[] {
     if (ns?.Parent) {
       return [ns.Id, ...findRoot(ns.Parent)];
@@ -52,9 +52,9 @@ export const CurrentChain = CurrentNamespace.asEffect().pipe(
   }),
 );
 
-export const Parent = Namespace.asEffect().pipe(Effect.map((ns) => ns?.Parent));
+export const Parent = Namespace.pipe(Effect.map((ns) => ns?.Parent));
 
-export const Root = Namespace.asEffect().pipe(
+export const Root = Namespace.pipe(
   Effect.map(function findRoot(ns) {
     if (ns.Parent) {
       return findRoot(ns.Parent);

package/src/Neon/Branch.ts

@@ -1,16 +1,43 @@
+import {
+  createProjectBranch,
+  deleteProjectBranch,
+  getConnectionURI,
+  getProjectBranch,
+  listProjectBranchDatabases,
+  listProjectBranches,
+  type ListProjectBranchesOutput,
+  updateProjectBranch,
+} from "@distilled.cloud/neon";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
 import { isResolved } from "../Diff.ts";
 import { createPhysicalName } from "../PhysicalName.ts";
 import * as Provider from "../Provider.ts";
 import { Resource } from "../Resource.ts";
-import * as api from "./api.ts";
 import { applyMigrations, runSql } from "./Migrations.ts";
 import { parsePostgresOrigin, type PostgresOrigin } from "./PostgresOrigin.ts";
-import type { Project } from "./Project.ts";
+import { type Project, waitForOperations } from "./Project.ts";
 import type { Providers } from "./Providers.ts";
 import { listSqlFiles, readSqlFile } from "./SqlFile.ts";
 
+const findBranchByName = (projectId: string, name: string) =>
+  Effect.gen(function* () {
+    const matches: ListProjectBranchesOutput["branches"][number][] = [];
+    let cursor: string | undefined;
+    do {
+      const page = yield* listProjectBranches({
+        project_id: projectId,
+        search: name,
+        ...(cursor !== undefined ? { cursor } : {}),
+      });
+      for (const b of page.branches) {
+        if (b.name === name) matches.push(b);
+      }
+      cursor = page.pagination?.next;
+    } while (cursor);
+    return matches;
+  });
+
 const DEFAULT_MIGRATIONS_TABLE = "neon_migrations";
 
 export type BranchSource =
@@ -202,7 +229,7 @@ const resolveParentBranchId = (
       return source.branchId as unknown as string;
     }
     if ("name" in source && source.name) {
-      const matches = yield* api.findBranchByName(projectId, source.name);
+      const matches = yield* findBranchByName(projectId, source.name);
       if (matches.length === 0) {
         return yield* Effect.die(
           `Parent branch "${source.name}" not found in project ${projectId}`,
@@ -218,9 +245,7 @@ const resolveParentBranchId = (
     return undefined as string | undefined;
   });
 
-const buildEndpoints = (
-  endpoints: BranchEndpointConfig[] | undefined,
-): api.CreateBranchEndpoint[] => {
+const buildEndpoints = (endpoints: BranchEndpointConfig[] | undefined) => {
   const list = endpoints ?? [{ type: "read_write" as const }];
   return list.map((e) => ({
     type: e.type,
@@ -237,13 +262,15 @@ const fetchConnection = (
   roleName: string,
 ) =>
   Effect.gen(function* () {
-    const direct = yield* api.getConnectionUri(projectId, {
+    const direct = yield* getConnectionURI({
+      project_id: projectId,
       branch_id: branchId,
       database_name: databaseName,
       role_name: roleName,
       pooled: false,
     });
-    const pooled = yield* api.getConnectionUri(projectId, {
+    const pooled = yield* getConnectionURI({
+      project_id: projectId,
       branch_id: branchId,
       database_name: databaseName,
       role_name: roleName,
@@ -318,31 +345,30 @@ export const BranchProvider = () =>
         }),
         read: Effect.fn(function* ({ id, output, olds }) {
           if (output?.branchId) {
-            return yield* api
-              .getProjectBranch(output.projectId, output.branchId)
-              .pipe(
-                Effect.map(({ branch }) => ({
-                  ...output,
-                  branchName: branch.name,
-                  protected: branch.protected,
-                  default: branch.default,
-                  expiresAt: branch.expires_at,
-                })),
-                Effect.catchTag("BranchNotFound", () =>
-                  Effect.succeed(undefined),
-                ),
-              );
+            return yield* getProjectBranch({
+              project_id: output.projectId,
+              branch_id: output.branchId,
+            }).pipe(
+              Effect.map(({ branch }) => ({
+                ...output,
+                branchName: branch.name,
+                protected: branch.protected,
+                default: branch.default,
+                expiresAt: branch.expires_at,
+              })),
+              Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+            );
           }
           if (!olds?.project) return undefined;
           const projectId = resolveProjectId(olds.project as BranchSource);
           const name = yield* createBranchName(id, olds.name);
-          const matches = yield* api.findBranchByName(projectId, name);
+          const matches = yield* findBranchByName(projectId, name);
           const match = matches[0];
           if (!match) return undefined;
-          const dbs = yield* api.listProjectBranchDatabases(
-            projectId,
-            match.id,
-          );
+          const dbs = yield* listProjectBranchDatabases({
+            project_id: projectId,
+            branch_id: match.id,
+          });
           const db = dbs.databases[0];
           if (!db) return undefined;
           const conn = yield* fetchConnection(
@@ -383,31 +409,33 @@ export const BranchProvider = () =>
           // otherwise sync the mutable scalar fields on the existing
           // branch via updateProjectBranch.
           const branchInfo = output
-            ? yield* api
-                .updateProjectBranch(output.projectId, output.branchId, {
+            ? yield* updateProjectBranch({
+                project_id: output.projectId,
+                branch_id: output.branchId,
+                branch: {
                   name: newName !== output.branchName ? newName : undefined,
                   protected: news.protected,
                   expires_at: news.expiresAt ?? null,
-                })
-                .pipe(
-                  Effect.map((r) => ({
-                    branchId: output.branchId,
-                    branchName: r.branch.name,
-                    projectId: output.projectId,
-                    parentBranchId: output.parentBranchId,
-                    parentLsn: output.parentLsn,
-                    parentTimestamp: output.parentTimestamp,
-                    initSource: output.initSource,
-                    protected: r.branch.protected,
-                    default: output.default,
-                    expiresAt: r.branch.expires_at,
-                    databaseName: output.databaseName,
-                    roleName: output.roleName,
-                    connectionUri: output.connectionUri,
-                    pooledConnectionUri: output.pooledConnectionUri,
-                    origin: output.origin,
-                  })),
-                )
+                },
+              }).pipe(
+                Effect.map((r) => ({
+                  branchId: output.branchId,
+                  branchName: r.branch.name,
+                  projectId: output.projectId,
+                  parentBranchId: output.parentBranchId,
+                  parentLsn: output.parentLsn,
+                  parentTimestamp: output.parentTimestamp,
+                  initSource: output.initSource,
+                  protected: r.branch.protected,
+                  default: output.default,
+                  expiresAt: r.branch.expires_at,
+                  databaseName: output.databaseName,
+                  roleName: output.roleName,
+                  connectionUri: output.connectionUri,
+                  pooledConnectionUri: output.pooledConnectionUri,
+                  origin: output.origin,
+                })),
+              )
             : yield* Effect.gen(function* () {
                 const projectId = resolveProjectId(
                   news.project as BranchSource,
@@ -416,17 +444,20 @@ export const BranchProvider = () =>
                   news.parentBranch as ParentBranchSource | undefined,
                   projectId,
                 );
-                const created = yield* api.createProjectBranch(projectId, {
-                  name: newName,
-                  parent_id: parentBranchId,
-                  parent_lsn: news.parentLsn,
-                  parent_timestamp: news.parentTimestamp,
-                  init_source: news.initSource,
-                  protected: news.protected,
-                  expires_at: news.expiresAt,
+                const created = yield* createProjectBranch({
+                  project_id: projectId,
+                  branch: {
+                    name: newName,
+                    parent_id: parentBranchId,
+                    parent_lsn: news.parentLsn,
+                    parent_timestamp: news.parentTimestamp,
+                    init_source: news.initSource,
+                    protected: news.protected,
+                    expires_at: news.expiresAt,
+                  },
                   endpoints: buildEndpoints(news.endpoints),
                 });
-                yield* api.waitForOperations(created.operations);
+                yield* waitForOperations(created.operations);
 
                 const db = created.databases[0];
                 if (!db) {
@@ -492,7 +523,10 @@ export const BranchProvider = () =>
           };
         }),
         delete: Effect.fn(function* ({ output }) {
-          yield* api.deleteProjectBranch(output.projectId, output.branchId);
+          yield* deleteProjectBranch({
+            project_id: output.projectId,
+            branch_id: output.branchId,
+          }).pipe(Effect.catchTag("NotFound", () => Effect.void));
         }),
       };
     }),