alchemy 2.0.0-beta.60 → 2.0.0-beta.61

package/src/Cloudflare/Workers/WorkerRuntimeContext.ts

@@ -11,7 +11,9 @@ import { makeRequestHandler } from "./HttpServer.ts";
 import {
   ExportedHandlerMethods,
   WorkerEnvironment,
+  WorkerExecutionContext,
   WorkerTypeId,
+  deferredExecutionContext,
   type WorkerEvent,
 } from "./Worker.ts";
 import type { WorkflowExport } from "../Workflows/Workflow.ts";
@@ -108,7 +110,13 @@ export const makeWorkerRuntimeContext = (id: string): WorkerRuntimeContext => {
       Effect.sync(() => {
         exports[name] = value;
       }),
-    planServices: Layer.succeed(WorkerEnvironment, {}),
+    planServices: Layer.mergeAll(
+      Layer.succeed(WorkerEnvironment, {}),
+      // Lets the init closure `yield*` WorkerExecutionContext during plan;
+      // its RuntimeContext-colored methods can't run until a real handler
+      // provides the live per-event context.
+      Layer.succeed(WorkerExecutionContext, deferredExecutionContext),
+    ),
     exports: Effect.gen(function* () {
       const handlers = yield* Effect.all(listeners, {
         concurrency: "unbounded",
@@ -125,12 +133,25 @@ export const makeWorkerRuntimeContext = (id: string): WorkerRuntimeContext => {
             env,
             context,
           };
+          const effects: Effect.Effect<unknown>[] = [];
           for (const handler of handlers) {
             const eff = handler(event);
             if (Effect.isEffect(eff)) {
-              return [eff, services];
+              effects.push(eff);
             }
           }
+          if (effects.length === 1) {
+            return [effects[0], services];
+          }
+          if (effects.length > 1) {
+            return [
+              Effect.all(effects, {
+                concurrency: "unbounded",
+                discard: true,
+              }),
+              services,
+            ];
+          }
           return [
             Effect.die(
               new Error(`No event handler found for event type '${type}'`),

package/src/Cloudflare/Workers/index.ts

@@ -2,6 +2,7 @@ export * from "./AccountSetting.ts";
 export * from "./Assets.ts";
 export * from "./Browser.ts";
 export * from "./BrowserBinding.ts";
+export * from "./Cache.ts";
 export * from "./ConfigProvider.ts";
 export * from "./CronEventSource.ts";
 export * from "./DurableObject.ts";

package/src/Cloudflare/WorkersForPlatforms/DispatchNamespace.ts

@@ -1,12 +1,11 @@
 import * as wfp from "@distilled.cloud/cloudflare/workers-for-platforms";
 import * as Effect from "effect/Effect";
-import * as Predicate from "effect/Predicate";
 import * as Stream from "effect/Stream";
 
 import { isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
-import { Resource } from "../../Resource.ts";
+import { isResourceOfType, Resource } from "../../Resource.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import type { Providers } from "../Providers.ts";
 
@@ -152,8 +151,7 @@ export const DispatchNamespace = Resource<DispatchNamespace>(TypeId);
  */
 export const isDispatchNamespace = (
   value: unknown,
-): value is DispatchNamespace =>
-  Predicate.hasProperty(value, "Type") && value.Type === TypeId;
+): value is DispatchNamespace => isResourceOfType(value, TypeId);
 
 export const DispatchNamespaceProvider = () =>
   Provider.succeed(DispatchNamespace, {

package/src/Cloudflare/Workflows/Workflow.ts

@@ -36,19 +36,119 @@ export class WorkflowEvent extends Context.Service<
     payload: unknown;
     timestamp: Date;
     instanceId: string;
+    workflowName: string;
+    schedule?: WorkflowCronSchedule;
   }
 >()("Cloudflare.Workflows.WorkflowEvent") {}
 
+export interface WorkflowCronSchedule {
+  cron: string;
+  scheduledTime: number;
+}
+
+export type WorkflowBackoff = "constant" | "linear" | "exponential";
+
+export interface WorkflowStepConfig {
+  retries?: {
+    limit: number;
+    delay: string | number;
+    backoff?: WorkflowBackoff;
+  };
+  timeout?: string | number;
+}
+
+export interface WorkflowStepContextData {
+  step: {
+    name: string;
+    count: number;
+  };
+  attempt: number;
+  config: WorkflowStepConfig;
+}
+
+/**
+ * Runtime information for the current `task` attempt.
+ */
+export class WorkflowStepContext extends Context.Service<
+  WorkflowStepContext,
+  WorkflowStepContextData
+>()("Cloudflare.WorkflowStepContext") {}
+
+export interface WorkflowRollbackContext<Output = unknown> {
+  error: Error;
+  output: Output | undefined;
+}
+
+export interface WorkflowRollbackOptions<Output = unknown, R = never> {
+  rollback: (
+    context: WorkflowRollbackContext<Output>,
+  ) => Effect.Effect<void, never, R>;
+  rollbackConfig?: WorkflowStepConfig;
+}
+
+/**
+ * Optional configuration for a `task` step: retry policy, timeout, and a
+ * rollback handler with its own retry config.
+ */
+export interface WorkflowTaskConfig<
+  Output = unknown,
+  RollbackReq = never,
+> extends WorkflowStepConfig {
+  rollback?: (
+    context: WorkflowRollbackContext<Output>,
+  ) => Effect.Effect<void, never, RollbackReq>;
+  rollbackConfig?: WorkflowStepConfig;
+}
+
+/**
+ * Internal step descriptor passed from `task` to the bridge. Bundles the step
+ * name and Effect together with the `WorkflowTaskConfig` fields.
+ */
+export interface WorkflowTaskOptions<
+  Output = unknown,
+  R = never,
+  RollbackReq = never,
+> extends WorkflowTaskConfig<Output, RollbackReq> {
+  name: string;
+  effect: Effect.Effect<Output, never, R>;
+}
+
+export interface WorkflowWaitForEventOptions {
+  type: string;
+  timeout?: string | number;
+}
+
+/**
+ * The event delivered to a `waitForEvent` step. Mirrors the native
+ * `WorkflowStepEvent` shape from `cloudflare:workers` 1:1.
+ */
+export interface WorkflowStepEvent<Payload = unknown> {
+  payload: Payload;
+  timestamp: Date;
+  type: string;
+}
+
+type ExcludeWorkflowStepContext<R> = R extends {
+  readonly key: "Cloudflare.WorkflowStepContext";
+}
+  ? never
+  : R;
+
 /**
  * Internal service that wraps the Cloudflare `WorkflowStep` object.
- * Not accessed directly by users -- use `task`, `sleep`, `sleepUntil` instead.
+ * Not accessed directly by users -- use `task`, `sleep`, `sleepUntil`, and
+ * `waitForEvent` instead.
  */
 export class WorkflowStep extends Context.Service<
   WorkflowStep,
   {
-    do<T>(name: string, effect: Effect.Effect<T>): Effect.Effect<T>;
+    do<T>(options: WorkflowTaskOptions<T, any, any>): Effect.Effect<T>;
     sleep(name: string, duration: string | number): Effect.Effect<void>;
     sleepUntil(name: string, timestamp: Date | number): Effect.Effect<void>;
+    waitForEvent<T>(
+      name: string,
+      options: WorkflowWaitForEventOptions,
+    ): Effect.Effect<WorkflowStepEvent<T>>;
   }
 >()("Cloudflare.Workflows.WorkflowStep") {}
 
@@ -65,16 +165,35 @@ export class WorkflowStep extends Context.Service<
  * 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`.
+ *
+ * The step name comes first, followed by the Effect. Retry config, timeout,
+ * and a rollback handler can be passed in the optional third `options` arg.
  */
-export const task = <T, R = never>(
+export function task<T, R = never, RollbackReq = never>(
   name: string,
   effect: Effect.Effect<T, never, R>,
-): Effect.Effect<T, never, WorkflowStep | R> =>
-  Effect.gen(function* () {
+  options?: WorkflowTaskConfig<T, RollbackReq>,
+): Effect.Effect<
+  T,
+  never,
+  WorkflowStep | ExcludeWorkflowStepContext<R | RollbackReq>
+> {
+  return Effect.gen(function* () {
     const step = yield* WorkflowStep;
-    const context = yield* Effect.context<R>();
-    return yield* step.do(name, effect.pipe(Effect.provide(context)));
+    const context =
+      yield* Effect.context<ExcludeWorkflowStepContext<R | RollbackReq>>();
+    const rollbackEffect = options?.rollback;
+    return yield* step.do({
+      ...options,
+      name,
+      effect: effect.pipe(Effect.provide(context)),
+      rollback: rollbackEffect
+        ? (rollbackContext: WorkflowRollbackContext<T>) =>
+            rollbackEffect(rollbackContext).pipe(Effect.provide(context))
+        : undefined,
+    } as WorkflowTaskOptions<T, any, any>);
   });
+}
 
 /**
  * Pause the workflow for the given duration.
@@ -83,10 +202,10 @@ export const sleep = (
   name: string,
   duration: string | number,
 ): Effect.Effect<void, never, WorkflowStep> =>
-  WorkflowStep.pipe(
-    Effect.flatMap((step) => step.sleep(name, duration)),
-    Effect.orDie,
-  );
+  Effect.gen(function* () {
+    const step = yield* WorkflowStep;
+    yield* step.sleep(name, duration);
+  }).pipe(Effect.orDie);
 
 /**
  * Pause the workflow until the given timestamp.
@@ -95,10 +214,25 @@ export const sleepUntil = (
   name: string,
   timestamp: Date | number,
 ): Effect.Effect<void, never, WorkflowStep> =>
-  WorkflowStep.pipe(
-    Effect.flatMap((step) => step.sleepUntil(name, timestamp)),
-    Effect.orDie,
-  );
+  Effect.gen(function* () {
+    const step = yield* WorkflowStep;
+    yield* step.sleepUntil(name, timestamp);
+  }).pipe(Effect.orDie);
+
+/**
+ * Pause the workflow until an external event is delivered with
+ * `WorkflowInstance.sendEvent`. Resolves with the full
+ * {@link WorkflowStepEvent} (`{ payload, timestamp, type }`), exactly like
+ * the native `step.waitForEvent`.
+ */
+export const waitForEvent = <T = unknown>(
+  name: string,
+  options: WorkflowWaitForEventOptions,
+): Effect.Effect<WorkflowStepEvent<T>, never, WorkflowStep> =>
+  Effect.gen(function* () {
+    const step = yield* WorkflowStep;
+    return yield* step.waitForEvent<T>(name, options);
+  }).pipe(Effect.orDie);
 
 /**
  * The services available inside a workflow run body.
@@ -216,22 +350,75 @@ export const isWorkflowBinding = (binding: {
 export interface WorkflowHandle<Input = unknown, Result = unknown> {
   Type: TypeId;
   name: string;
-  create(input: Input): Effect.Effect<WorkflowInstance<Result>>;
+  /**
+   * Start a workflow instance. Pass payload through `params`; omit `id` to let
+   * Cloudflare generate an instance ID.
+   */
+  create(
+    options?: WorkflowInstanceCreateOptions<Input>,
+  ): Effect.Effect<WorkflowInstance<Result>>;
+  createBatch(
+    batch: WorkflowInstanceCreateOptions<Input>[],
+  ): Effect.Effect<WorkflowInstance<Result>[]>;
   get(instanceId: string): Effect.Effect<WorkflowInstance<Result>>;
 }
 
+/** Options for starting a workflow instance. */
+export interface WorkflowInstanceCreateOptions<Input = unknown> {
+  id?: string;
+  params?: Input;
+  retention?: WorkflowInstanceRetention;
+}
+
+export interface WorkflowInstanceRetention {
+  successRetention?: string | number;
+  errorRetention?: string | number;
+}
+
+/** Handle for a single Cloudflare workflow instance. */
 export interface WorkflowInstance<Result = unknown> {
   id: string;
   status(): Effect.Effect<WorkflowInstanceStatus<Result>>;
   pause(): Effect.Effect<void>;
   resume(): Effect.Effect<void>;
+  restart(options?: WorkflowInstanceRestartOptions): Effect.Effect<void>;
   terminate(): Effect.Effect<void>;
+  sendEvent<Event = unknown>(
+    event: WorkflowInstanceEvent<Event>,
+  ): Effect.Effect<void>;
+}
+
+export interface WorkflowInstanceRestartOptions {
+  from?: {
+    name: string;
+    count?: number;
+    type?: "do" | "sleep" | "waitForEvent";
+  };
+}
+
+export interface WorkflowInstanceEvent<Payload = unknown> {
+  type: string;
+  payload?: Payload;
 }
 
 export interface WorkflowInstanceStatus<Result = unknown> {
-  status: string;
+  status:
+    | "queued"
+    | "running"
+    | "paused"
+    | "errored"
+    | "terminated"
+    | "complete"
+    | "waiting"
+    | "waitingForPause"
+    | "unknown"
+    | (string & {});
   output?: Result;
   error?: { name: string; message: string } | null;
+  rollback?: {
+    outcome: "complete" | "failed";
+    error: { name: string; message: string } | null;
+  } | null;
 }
 
 export interface WorkflowClass extends Effect.Effect<
@@ -278,7 +465,8 @@ export class WorkflowScope extends Context.Service<
  * Objects. The outer `Effect.gen` resolves shared dependencies. The inner
  * `Effect.fn` is the workflow body — a function from a typed `input`
  * payload to an Effect that runs steps using `task`, `sleep`, and
- * `sleepUntil`.
+ * `sleepUntil`. `task` takes the step name and Effect, plus an optional
+ * config object for retries, timeout, and a rollback handler.
  *
  * ```typescript
  * Effect.gen(function* () {
@@ -320,11 +508,42 @@ export class WorkflowScope extends Context.Service<
  * );
  * ```
  *
+ * @example Configuring retries and reading step context
+ * ```typescript
+ * const result = yield* Cloudflare.Workflows.task(
+ *   "call-api",
+ *   Effect.gen(function* () {
+ *     const context = yield* Cloudflare.Workflows.WorkflowStepContext;
+ *     return { attempt: context.attempt };
+ *   }),
+ *   { retries: { limit: 3, delay: "5 seconds", backoff: "linear" } },
+ * );
+ * ```
+ *
+ * @example Registering rollback
+ * ```typescript
+ * yield* Cloudflare.Workflows.task("reserve-inventory", reserveInventory, {
+ *   rollback: ({ output }) =>
+ *     output ? releaseInventory(output.reservationId) : Effect.void,
+ *   rollbackConfig: { retries: { limit: 3, delay: "10 seconds" } },
+ * });
+ * ```
+ *
  * @example Sleeping between steps
  * ```typescript
  * yield* Cloudflare.Workflows.sleep("cooldown", "30 seconds");
  * ```
  *
+ * @example Waiting for an external event
+ * ```typescript
+ * const event = yield* Cloudflare.Workflows.waitForEvent<{ approved: boolean }>(
+ *   "approval",
+ *   { type: "approval", timeout: "1 day" },
+ * );
+ * // Same shape as the native step.waitForEvent result:
+ * event.payload.approved;
+ * ```
+ *
  * @example Accessing env bindings inside a task
  * Bind a resource (e.g. `Namespace`, `Bucket`) in the workflow's
  * outer init phase to get a typed Effect-native client, then use it
@@ -354,10 +573,31 @@ export class WorkflowScope extends Context.Service<
  * ```
  *
  * @section Starting and Monitoring Instances
+ * `create` mirrors Cloudflare's native Workflow API: pass workflow input in
+ * `params`, pass `id` only when you need a deterministic instance ID, and omit
+ * `id` to let Cloudflare generate one.
+ *
  * @example Creating an instance from a Worker
  * ```typescript
  * const workflow = yield* MyWorkflow;
- * const instance = yield* workflow.create({ orderId: "abc" });
+ * const instance = yield* workflow.create({ params: { orderId: "abc" } });
+ * ```
+ *
+ * @example Creating an instance with id and retention
+ * ```typescript
+ * const instance = yield* workflow.create({
+ *   id: "order-abc",
+ *   params: { orderId: "abc" },
+ *   retention: { successRetention: "1 day", errorRetention: "7 days" },
+ * });
+ * ```
+ *
+ * @example Creating a batch
+ * ```typescript
+ * const instances = yield* workflow.createBatch([
+ *   { id: "order-a", params: { orderId: "a" } },
+ *   { id: "order-b", params: { orderId: "b" } },
+ * ]);
  * ```
  *
  * @example Checking instance status
@@ -367,6 +607,13 @@ export class WorkflowScope extends Context.Service<
  * const status = yield* handle.status();
  * ```
  *
+ * @example Sending events and restarting instances
+ * ```typescript
+ * const instance = yield* workflow.get(instanceId);
+ * yield* instance.sendEvent({ type: "approval", payload: { approved: true } });
+ * yield* instance.restart({ from: { name: "approval", type: "waitForEvent" } });
+ * ```
+ *
  * @section Triggering from a Worker
  * Wire the workflow into HTTP routes so callers can fire instances
  * and poll for completion.
@@ -382,7 +629,7 @@ export class WorkflowScope extends Context.Service<
  *
  *     if (request.url.startsWith("/workflow/start/")) {
  *       const id = request.url.split("/").pop()!;
- *       const instance = yield* notifier.create({ id });
+ *       const instance = yield* notifier.create({ params: { orderId: id } });
  *       return HttpServerResponse.json({ instanceId: instance.id });
  *     }
  *
@@ -462,9 +709,8 @@ export class WorkflowScope extends Context.Service<
  * ```
  *
  * @section Testing Workflows
- * Workflows run asynchronously, so tests start an instance and
- * poll until it reaches a terminal status. A simple recipe with
- * `alchemy/Test/Bun`:
+ * Workflows run asynchronously, so tests start an instance and poll until it
+ * reaches a terminal status. Keep polling bounded with `Effect.repeat`.
  *
  * @example Polling for workflow completion
  * ```typescript
@@ -476,20 +722,20 @@ export class WorkflowScope extends Context.Service<
  *     const start = yield* HttpClient.post(`${url}/workflow/start/x`);
  *     const { instanceId } = (yield* start.json) as { instanceId: string };
  *
- *     let status: { status: string } | undefined;
- *     const deadline = Date.now() + 60_000;
- *     while (Date.now() < deadline) {
- *       const res = yield* HttpClient.get(
- *         `${url}/workflow/status/${instanceId}`,
- *       );
- *       status = (yield* res.json) as { status: string };
- *       if (status.status === "complete" || status.status === "errored") {
- *         break;
- *       }
- *       yield* Effect.sleep("2 seconds");
- *     }
+ *     const status = yield* HttpClient.get(
+ *       `${url}/workflow/status/${instanceId}`,
+ *     ).pipe(
+ *       Effect.flatMap((res) => res.json),
+ *       Effect.map((json) => json as { status: string }),
+ *       Effect.repeat({
+ *         schedule: Schedule.spaced("2 seconds"),
+ *         until: (status) =>
+ *           status.status === "complete" || status.status === "errored",
+ *         times: 30,
+ *       }),
+ *     );
  *
- *     expect(status?.status).toBe("complete");
+ *     expect(status.status).toBe("complete");
  *   }),
  *   { timeout: 120_000 },
  * );
@@ -563,11 +809,18 @@ export const Workflow: WorkflowClass = taggedFunction(WorkflowScope, ((
       const self: WorkflowHandle<any, any> = {
         Type: TypeId,
         name,
-        create: (input: unknown) =>
-          Effect.tryPromise(() => binding.create({ params: input })).pipe(
+        create: (options?: WorkflowInstanceCreateOptions<any>) =>
+          Effect.tryPromise(() => binding.create(options)).pipe(
             Effect.map(wrapInstance),
             Effect.orDie,
           ),
+        createBatch: (batch: WorkflowInstanceCreateOptions<any>[]) =>
+          Effect.tryPromise(
+            () => binding.createBatch(batch) as Promise<any[]>,
+          ).pipe(
+            Effect.map((instances: any[]) => instances.map(wrapInstance)),
+            Effect.orDie,
+          ),
         get: (instanceId: string) =>
           Effect.tryPromise(() => binding.get(instanceId)).pipe(
             Effect.map(wrapInstance),
@@ -725,10 +978,15 @@ const wrapInstance = <Result>(raw: any): WorkflowInstance<Result> => ({
         status: s.status as string,
         output: s.output as Result,
         error: s.error,
+        rollback: s.rollback,
       })),
       Effect.orDie,
     ),
   pause: () => Effect.tryPromise(() => raw.pause()).pipe(Effect.orDie),
   resume: () => Effect.tryPromise(() => raw.resume()).pipe(Effect.orDie),
+  restart: (options?: WorkflowInstanceRestartOptions) =>
+    Effect.tryPromise(() => raw.restart(options)).pipe(Effect.orDie),
   terminate: () => Effect.tryPromise(() => raw.terminate()).pipe(Effect.orDie),
+  sendEvent: <Event = unknown>(event: WorkflowInstanceEvent<Event>) =>
+    Effect.tryPromise(() => raw.sendEvent(event)).pipe(Effect.orDie),
 });

package/src/Cloudflare/Workflows/WorkflowBridge.ts

@@ -11,6 +11,10 @@ import {
   type WorkflowExport,
   type WorkflowImpl,
   WorkflowStep,
+  WorkflowStepContext,
+  type WorkflowStepConfig,
+  type WorkflowStepEvent,
+  type WorkflowTaskOptions,
 } from "./Workflow.ts";
 
 /**
@@ -105,29 +109,75 @@ export const makeWorkflowBridge =
       }
     };
 
-const wrapWorkflowEvent = (
-  event: any,
-): { payload: unknown; timestamp: Date; instanceId: string } => ({
+const wrapWorkflowEvent = (event: any): WorkflowEventService["Service"] => ({
   payload: event.payload,
   timestamp:
     event.timestamp instanceof Date
       ? event.timestamp
       : new Date(event.timestamp),
   instanceId: event.instanceId ?? "",
+  workflowName: event.workflowName ?? "",
+  schedule: event.schedule,
 });
 
 const wrapWorkflowStep = (step: any): WorkflowStep["Service"] => ({
-  do: <T>(name: string, effect: Effect.Effect<T>): Effect.Effect<T> =>
-    Effect.tryPromise(
-      () => step.do(name, () => Effect.runPromise(effect)) as Promise<T>,
-    ),
+  do: <T>(options: WorkflowTaskOptions<T, any, any>): Effect.Effect<T> => {
+    const { name } = options;
+    // The surrounding body context is already provided in `task`; the bridge
+    // supplies `WorkflowStepContext` and runs the step to completion, so the
+    // effect is fully satisfied (R = never) at this boundary.
+    const effect = options.effect as Effect.Effect<
+      T,
+      never,
+      WorkflowStepContext
+    >;
+    const config = toWorkflowStepConfig(options);
+    const rollbackEffect = options.rollback;
+    const callback = (context: any) =>
+      Effect.runPromise(
+        effect.pipe(
+          Effect.provideService(WorkflowStepContext, {
+            step: context.step,
+            attempt: context.attempt,
+            config: context.config,
+          }),
+        ),
+      );
+    const rollback = rollbackEffect
+      ? {
+          rollback: (context: any) =>
+            Effect.runPromise(
+              rollbackEffect({
+                error: context.error,
+                output: context.output,
+              }) as Effect.Effect<void>,
+            ),
+          rollbackConfig: options.rollbackConfig,
+        }
+      : undefined;
+    return Effect.tryPromise(() => {
+      if (config && rollback) return step.do(name, config, callback, rollback);
+      if (config) return step.do(name, config, callback);
+      if (rollback) return step.do(name, callback, rollback);
+      return step.do(name, callback);
+    });
+  },
   sleep: (name: string, duration: string | number): Effect.Effect<void> =>
     Effect.tryPromise(() => step.sleep(name, duration)),
   sleepUntil: (name: string, timestamp: Date | number): Effect.Effect<void> =>
-    Effect.tryPromise(() =>
-      step.sleepUntil(
-        name,
-        timestamp instanceof Date ? timestamp.toISOString() : timestamp,
-      ),
+    Effect.tryPromise(() => step.sleepUntil(name, timestamp)),
+  waitForEvent: <T>(
+    name: string,
+    options: any,
+  ): Effect.Effect<WorkflowStepEvent<T>> =>
+    Effect.tryPromise(
+      () => step.waitForEvent(name, options) as Promise<WorkflowStepEvent<T>>,
     ),
 });
+
+const toWorkflowStepConfig = (
+  options: WorkflowTaskOptions<any, any, any>,
+): WorkflowStepConfig | undefined => {
+  if (!options.retries && !options.timeout) return undefined;
+  return { retries: options.retries, timeout: options.timeout };
+};

package/src/Cloudflare/Zaraz/Config.ts

@@ -185,7 +185,9 @@ export type ConfigAttributes = {
  * ```
  */
 export const Config = Object.assign(
-  Resource<Config>("Cloudflare.Zaraz.Config"),
+  Resource<Config>("Cloudflare.Zaraz.Config", {
+    aliases: ["Cloudflare.ZarazConfig"],
+  }),
   {
     /**
      * Define a type-only contract for the events sent through this Zaraz config.
@@ -251,7 +253,10 @@ export const ConfigProvider = () =>
     }),
     read: Effect.fn(function* ({ olds, output }) {
       const zoneId =
-        output?.zoneId ?? (olds ? yield* resolve(olds.zone) : undefined);
+        // `olds.zone` may be `undefined` when a `creating` row was persisted
+        // before upstream Outputs resolved — report "not found" then.
+        output?.zoneId ??
+        (olds?.zone !== undefined ? yield* resolve(olds.zone) : undefined);
       if (!zoneId) return undefined;
       return yield* observe(zoneId);
     }),

package/src/Cloudflare/Zone/Zone.ts

@@ -190,6 +190,7 @@ export type Zone = Resource<
  */
 export const Zone = Resource<Zone>("Cloudflare.Zone.Zone", {
   defaultRemovalPolicy: "retain",
+  aliases: ["Cloudflare.Zone"],
 });
 
 export const ZoneProvider = () =>