alchemy 2.0.0-beta.35 → 2.0.0-beta.37

package/src/Cloudflare/Images/ImagesBinding.ts

@@ -0,0 +1,192 @@
+import type * as cf from "@cloudflare/workers-types";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import * as Binding from "../../Binding.ts";
+import type { ResourceLike } from "../../Resource.ts";
+import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
+import { type Images as ImagesLike } from "./Images.ts";
+
+export class ImagesError extends Data.TaggedError("ImagesError")<{
+  message: string;
+  code?: number;
+  cause: unknown;
+}> {}
+
+/**
+ * Effect-native handle to the result of `input(...).output(...)`.
+ * Mirrors the runtime `ImageTransformationResult` but exposes side
+ * effects (response/image/contentType reads) as plain sync effects.
+ */
+export interface ImageTransformationResultClient {
+  raw: cf.ImageTransformationResult;
+  response: Effect.Effect<cf.Response>;
+  contentType: Effect.Effect<string>;
+  image(
+    options?: cf.ImageTransformationOutputOptions,
+  ): Effect.Effect<cf.ReadableStream<Uint8Array>>;
+}
+
+/**
+ * Effect-native chainable transformer. `transform`/`draw` are pure
+ * (return a new client wrapping the next runtime transformer);
+ * `output` is the only step that crosses into Cloudflare's runtime
+ * and therefore returns an Effect.
+ */
+export interface ImageTransformerClient {
+  raw: cf.ImageTransformer;
+  transform(transform: cf.ImageTransform): ImageTransformerClient;
+  draw<E = never, R = never>(
+    image: Stream.Stream<Uint8Array, E, R> | ImageTransformerClient,
+    options?: cf.ImageDrawOptions,
+  ): Effect.Effect<ImageTransformerClient, never, R>;
+  output(
+    options: cf.ImageOutputOptions,
+  ): Effect.Effect<ImageTransformationResultClient, ImagesError>;
+}
+
+/**
+ * Effect-native client for a Cloudflare Images binding.
+ *
+ * Wraps the runtime {@link cf.ImagesBinding} so each method returns
+ * an Effect tagged with {@link ImagesError}. Use
+ * `Cloudflare.Images.bind(images)` inside a Worker's init phase.
+ */
+export interface ImagesClient {
+  /** Effect resolving to the raw Cloudflare runtime binding. */
+  raw: Effect.Effect<cf.ImagesBinding, never, WorkerEnvironment>;
+  /**
+   * Read image format and dimensions from a stream of bytes.
+   * Fails with {@link ImagesError} (code 9412) if the input is not
+   * a recognized image.
+   */
+  info<E = never, R = never>(
+    stream: Stream.Stream<Uint8Array, E, R>,
+    options?: cf.ImageInputOptions,
+  ): Effect.Effect<cf.ImageInfoResponse, ImagesError, WorkerEnvironment | R>;
+  /**
+   * Begin a transformation pipeline. Subsequent `.transform()` /
+   * `.draw()` calls are pure; `.output(opts)` runs the pipeline.
+   */
+  input<E = never, R = never>(
+    stream: Stream.Stream<Uint8Array, E, R>,
+    options?: cf.ImageInputOptions,
+  ): Effect.Effect<ImageTransformerClient, never, WorkerEnvironment | R>;
+}
+
+export class ImagesBinding extends Binding.Service<
+  ImagesBinding,
+  (images: ImagesLike) => Effect.Effect<ImagesClient>
+>()("Cloudflare.Images.Binding") {}
+
+export const ImagesBindingLive = Layer.effect(
+  ImagesBinding,
+  Effect.gen(function* () {
+    const Policy = yield* ImagesBindingPolicy;
+
+    return Effect.fn(function* (images: ImagesLike) {
+      yield* Policy(images);
+      const env = WorkerEnvironment.asEffect();
+      const raw = env.pipe(
+        Effect.map(
+          (env) => (env as Record<string, cf.ImagesBinding>)[images.name]!,
+        ),
+      );
+
+      return {
+        raw,
+        info: (stream, options) =>
+          Effect.gen(function* () {
+            const binding = yield* raw;
+            const readable = yield* toCfReadable(stream);
+            return yield* tryPromise(() => binding.info(readable, options));
+          }),
+        input: (stream, options) =>
+          Effect.gen(function* () {
+            const binding = yield* raw;
+            const readable = yield* toCfReadable(stream);
+            return wrapTransformer(binding.input(readable, options));
+          }),
+      } satisfies ImagesClient;
+    });
+  }),
+);
+
+export class ImagesBindingPolicy extends Binding.Policy<
+  ImagesBindingPolicy,
+  (images: ImagesLike) => Effect.Effect<void>
+>()("Cloudflare.Images.Binding") {}
+
+export const ImagesBindingPolicyLive = ImagesBindingPolicy.layer.succeed(
+  Effect.fn(function* (host: ResourceLike, images: ImagesLike) {
+    if (isWorker(host)) {
+      yield* host.bind(images.name, {
+        bindings: [
+          {
+            type: "images",
+            name: images.name,
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        new Error(`ImagesBinding does not support runtime '${host.Type}'`),
+      );
+    }
+  }),
+);
+
+const tryPromise = <T>(fn: () => Promise<T>): Effect.Effect<T, ImagesError> =>
+  Effect.tryPromise({
+    try: fn,
+    catch: (error: any) =>
+      new ImagesError({
+        message: error?.message ?? "Unknown error",
+        code: typeof error?.code === "number" ? error.code : undefined,
+        cause: error,
+      }),
+  });
+
+/**
+ * Convert an Effect `Stream<Uint8Array>` into the `cf.ReadableStream<Uint8Array>`
+ * shape that the Cloudflare Images runtime binding expects. The two
+ * `ReadableStream` types only differ at the type level; at runtime they
+ * are the same Web Streams API.
+ */
+const toCfReadable = <E, R>(
+  stream: Stream.Stream<Uint8Array, E, R>,
+): Effect.Effect<cf.ReadableStream<Uint8Array>, never, R> =>
+  Stream.toReadableStreamEffect(stream).pipe(
+    Effect.map((s) => s as unknown as cf.ReadableStream<Uint8Array>),
+  );
+
+const isTransformerClient = (image: unknown): image is ImageTransformerClient =>
+  typeof image === "object" && image !== null && "raw" in image;
+
+const wrapTransformer = (raw: cf.ImageTransformer): ImageTransformerClient => ({
+  raw,
+  transform: (transform) => wrapTransformer(raw.transform(transform)),
+  draw: <E, R>(
+    image: Stream.Stream<Uint8Array, E, R> | ImageTransformerClient,
+    options?: cf.ImageDrawOptions,
+  ): Effect.Effect<ImageTransformerClient, never, R> => {
+    if (isTransformerClient(image)) {
+      return Effect.succeed(wrapTransformer(raw.draw(image.raw, options)));
+    }
+    return toCfReadable(image).pipe(
+      Effect.map((readable) => wrapTransformer(raw.draw(readable, options))),
+    );
+  },
+  output: (options) =>
+    tryPromise(() => raw.output(options)).pipe(Effect.map(wrapResult)),
+});
+
+const wrapResult = (
+  raw: cf.ImageTransformationResult,
+): ImageTransformationResultClient => ({
+  raw,
+  response: Effect.sync(() => raw.response()),
+  contentType: Effect.sync(() => raw.contentType()),
+  image: (options) => Effect.sync(() => raw.image(options)),
+});

package/src/Cloudflare/Images/index.ts

@@ -0,0 +1,2 @@
+export * from "./Images.ts";
+export * from "./ImagesBinding.ts";

package/src/Cloudflare/Local/SidecarHandlers.ts

@@ -169,7 +169,15 @@ function bundleOutputToWorkerModules(
 ): WorkerModule[] {
   const modules: WorkerModule[] = [];
   for (const file of bundle.files) {
-    if (file.path.endsWith(".map") || file.content instanceof Uint8Array) {
+    if (file.path.endsWith(".map")) {
+      continue;
+    }
+    if (file.content instanceof Uint8Array) {
+      modules.push({
+        name: file.path,
+        type: file.path.endsWith(".wasm") ? "Wasm" : "Data",
+        content: file.content,
+      });
       continue;
     }
     modules.push({

package/src/Cloudflare/Providers.ts

@@ -13,6 +13,7 @@ import { ProfileLive } from "../Auth/Profile.ts";
 import { Random, RandomProvider } from "../Random.ts";
 import * as Access from "./Access.ts";
 import * as AiGateway from "./AiGateway/index.ts";
+import * as AnalyticsEngine from "./AnalyticsEngine/index.ts";
 import * as ApiToken from "./ApiToken/index.ts";
 import * as Artifacts from "./Artifacts/index.ts";
 import { CloudflareAuth } from "./Auth/AuthProvider.ts";
@@ -21,6 +22,7 @@ import * as Containers from "./Container/index.ts";
 import * as Credentials from "./Credentials.ts";
 import * as D1 from "./D1/index.ts";
 import * as Hyperdrive from "./Hyperdrive/index.ts";
+import * as Images from "./Images/index.ts";
 import * as KV from "./KV/index.ts";
 import * as Queue from "./Queue/index.ts";
 import * as R2 from "./R2/index.ts";
@@ -49,6 +51,7 @@ export const providers = () =>
       ApiToken.UserApiToken,
       AiGateway.AiGateway,
       AiGateway.AiGatewayBindingPolicy,
+      AnalyticsEngine.AnalyticsEngineDatasetBindingPolicy,
       Artifacts.ArtifactsBindingPolicy,
       Command,
       Containers.Container,
@@ -56,6 +59,7 @@ export const providers = () =>
       D1.D1Database,
       Hyperdrive.Hyperdrive,
       Hyperdrive.HyperdriveBindingPolicy,
+      Images.ImagesBindingPolicy,
       KV.KVNamespace,
       KV.KVNamespaceBindingPolicy,
       Queue.Queue,
@@ -71,6 +75,7 @@ export const providers = () =>
       VpcService.VpcService,
       Random,
       Workers.BindWorkerPolicy,
+      Workers.CronEventSourcePolicy,
       Workers.FetchPolicy,
       Workers.Worker,
       Workflows.WorkflowResource,
@@ -82,12 +87,14 @@ export const providers = () =>
         ApiToken.UserApiTokenProvider(),
         AiGateway.AiGatewayProvider(),
         AiGateway.AiGatewayBindingPolicyLive,
+        AnalyticsEngine.AnalyticsEngineDatasetBindingPolicyLive,
         Artifacts.ArtifactsBindingPolicyLive,
         Containers.ContainerProvider(),
         D1.D1ConnectionPolicyLive,
         D1.DatabaseProvider(),
         Hyperdrive.HyperdriveBindingPolicyLive,
         Hyperdrive.HyperdriveProvider(),
+        Images.ImagesBindingPolicyLive,
         KV.KVNamespaceBindingPolicyLive,
         KV.KVNamespaceProvider(),
         Queue.QueueBindingPolicyLive,
@@ -102,6 +109,7 @@ export const providers = () =>
         Tunnel.TunnelProvider(),
         VpcService.VpcServiceProvider(),
         Workers.BindWorkerPolicyLive,
+        Workers.CronEventSourcePolicyLive,
         Workers.FetchPolicyLive,
         Workers.WorkerProvider(),
         Workflows.WorkflowProvider(),

package/src/Cloudflare/R2/R2Bucket.ts

@@ -1,6 +1,7 @@
 import * as r2 from "@distilled.cloud/cloudflare/r2";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
 
 import { deepEqual, isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
@@ -42,6 +43,60 @@ export type R2BucketCustomDomain = {
   minTLS?: "1.0" | "1.1" | "1.2" | "1.3";
 };
 
+export type R2BucketLifecycleCondition =
+  | {
+      type: "Age";
+      /**
+       * Maximum age of an object, in seconds, before the rule's action applies.
+       */
+      maxAge: number;
+    }
+  | {
+      type: "Date";
+      /**
+       * Absolute date (ISO 8601) at which the rule's action applies.
+       */
+      date: string;
+    };
+
+export type R2BucketLifecycleRule = {
+  /**
+   * Unique identifier for the rule within the bucket.
+   */
+  id: string;
+  /**
+   * Whether the rule is enabled.
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Object key prefix the rule applies to. Use `""` (or omit) to match all
+   * objects in the bucket.
+   * @default ""
+   */
+  prefix?: string;
+  /**
+   * Abort incomplete multipart uploads after the configured age.
+   */
+  abortMultipartUploadsTransition?: {
+    condition?: { type: "Age"; maxAge: number };
+  };
+  /**
+   * Delete matching objects after the configured age or on a specific date.
+   */
+  deleteObjectsTransition?: {
+    condition?: R2BucketLifecycleCondition;
+  };
+  /**
+   * Transition matching objects to a different storage class. Cloudflare R2
+   * only supports transitioning to `InfrequentAccess` today.
+   */
+  storageClassTransitions?: {
+    condition: R2BucketLifecycleCondition;
+    storageClass: "InfrequentAccess";
+  }[];
+};
+
 export type R2BucketProps = {
   /**
    * Name of the bucket. If omitted, a unique name will be generated.
@@ -67,6 +122,12 @@ export type R2BucketProps = {
    * to remove all custom domains.
    */
   domains?: R2BucketCustomDomain[];
+  /**
+   * Object lifecycle rules applied to the bucket. Pass an empty array (or
+   * omit) to clear all lifecycle rules. See the Cloudflare R2 docs for
+   * supported transitions.
+   */
+  lifecycleRules?: R2BucketLifecycleRule[];
 };
 
 export type R2Bucket = Resource<
@@ -79,6 +140,7 @@ export type R2Bucket = Resource<
     location: R2Bucket.Location | undefined;
     accountId: string;
     domains: R2Bucket.CustomDomain[];
+    lifecycleRules: R2Bucket.LifecycleRule[];
   },
   never,
   Cloudflare.Providers
@@ -175,6 +237,63 @@ export type R2Bucket = Resource<
  *   ],
  * });
  * ```
+ *
+ * @section Object Lifecycle Rules
+ *
+ * Configure lifecycle rules to automatically delete objects, abort
+ * incomplete multipart uploads, or transition objects to InfrequentAccess
+ * storage. Pass an empty array (or omit) to clear all rules. See the
+ * [Cloudflare R2 docs](https://developers.cloudflare.com/r2/buckets/object-lifecycles/)
+ * for details and limits (max 1000 rules per bucket).
+ *
+ * @example Delete objects 30 days after upload
+ * ```typescript
+ * const bucket = yield* Cloudflare.R2Bucket("MyBucket", {
+ *   lifecycleRules: [
+ *     {
+ *       id: "expire-old-objects",
+ *       deleteObjectsTransition: {
+ *         condition: { type: "Age", maxAge: 60 * 60 * 24 * 30 },
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * @example Transition to InfrequentAccess after 60 days, delete after 365
+ * ```typescript
+ * const bucket = yield* Cloudflare.R2Bucket("MyBucket", {
+ *   lifecycleRules: [
+ *     {
+ *       id: "archive-then-delete",
+ *       prefix: "logs/",
+ *       storageClassTransitions: [
+ *         {
+ *           condition: { type: "Age", maxAge: 60 * 60 * 24 * 60 },
+ *           storageClass: "InfrequentAccess",
+ *         },
+ *       ],
+ *       deleteObjectsTransition: {
+ *         condition: { type: "Age", maxAge: 60 * 60 * 24 * 365 },
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * @example Abort incomplete multipart uploads after 7 days
+ * ```typescript
+ * const bucket = yield* Cloudflare.R2Bucket("MyBucket", {
+ *   lifecycleRules: [
+ *     {
+ *       id: "abort-stale-uploads",
+ *       abortMultipartUploadsTransition: {
+ *         condition: { type: "Age", maxAge: 60 * 60 * 24 * 7 },
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
  */
 export const R2Bucket = Resource<R2Bucket>("Cloudflare.R2Bucket")({
   bind: R2BucketBinding.bind,
@@ -184,6 +303,23 @@ export declare namespace R2Bucket {
   export type StorageClass = "Standard" | "InfrequentAccess";
   export type Jurisdiction = "default" | "eu" | "fedramp";
   export type Location = "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc";
+  export type LifecycleRule = {
+    id: string;
+    enabled: boolean;
+    prefix: string;
+    abortMultipartUploadsTransition:
+      | { condition: { type: "Age"; maxAge: number } | undefined }
+      | undefined;
+    deleteObjectsTransition:
+      | { condition: R2BucketLifecycleCondition | undefined }
+      | undefined;
+    storageClassTransitions:
+      | {
+          condition: R2BucketLifecycleCondition;
+          storageClass: "InfrequentAccess";
+        }[]
+      | undefined;
+  };
   export type CustomDomain = {
     domain: string;
     zoneId: string | undefined;
@@ -220,10 +356,41 @@ export const R2BucketProvider = () =>
       const patchBucket = yield* r2.patchBucket;
       const deleteBucket = yield* r2.deleteBucket;
       const getBucket = yield* r2.getBucket;
+      const deleteObjects = yield* r2.deleteObjects;
       const listBucketDomainCustoms = yield* r2.listBucketDomainCustoms;
       const createBucketDomainCustom = yield* r2.createBucketDomainCustom;
       const updateBucketDomainCustom = yield* r2.updateBucketDomainCustom;
       const deleteBucketDomainCustom = yield* r2.deleteBucketDomainCustom;
+      const getBucketLifecycle = yield* r2.getBucketLifecycle;
+      const putBucketLifecycle = yield* r2.putBucketLifecycle;
+
+      const emptyBucket = (
+        bucketName: string,
+        jurisdiction: R2Bucket.Jurisdiction,
+      ) =>
+        r2.listObjects
+          .items({
+            accountId,
+            bucketName,
+            cfR2Jurisdiction: jurisdiction,
+            perPage: 1000,
+          })
+          .pipe(
+            Stream.filter(
+              (o): o is typeof o & { key: string } =>
+                typeof o.key === "string" && o.key !== "",
+            ),
+            Stream.map((o) => o.key),
+            Stream.runForEachArray((chunk) =>
+              deleteObjects({
+                accountId,
+                bucketName,
+                cfR2Jurisdiction: jurisdiction,
+                body: [...chunk],
+              }),
+            ),
+            Effect.catchTag("NoSuchBucket", () => Effect.void),
+          );
 
       const createBucketName = (id: string, name: string | undefined) =>
         Effect.gen(function* () {
@@ -252,7 +419,7 @@ export const R2BucketProvider = () =>
         }).pipe(
           Effect.retry({
             while: isNoSuchBucket,
-            schedule: r2CustomDomainConsistencySchedule,
+            schedule: r2BucketEndpointConsistencySchedule,
           }),
           Effect.map((response) =>
             response.domains.map(toCustomDomainAttributes),
@@ -351,7 +518,7 @@ export const R2BucketProvider = () =>
                   }).pipe(
                     Effect.retry({
                       while: isNoSuchBucket,
-                      schedule: r2CustomDomainConsistencySchedule,
+                      schedule: r2BucketEndpointConsistencySchedule,
                     }),
                   );
                   return toCustomDomainAttributes({ ...created, zoneId });
@@ -368,7 +535,7 @@ export const R2BucketProvider = () =>
                 }).pipe(
                   Effect.retry({
                     while: isNoSuchBucket,
-                    schedule: r2CustomDomainConsistencySchedule,
+                    schedule: r2BucketEndpointConsistencySchedule,
                   }),
                 );
                 return toCustomDomainAttributes({
@@ -383,6 +550,45 @@ export const R2BucketProvider = () =>
           return applied.sort((a, b) => a.domain.localeCompare(b.domain));
         });
 
+      const reconcileLifecycleRules = (
+        bucketName: string,
+        jurisdiction: R2Bucket.Jurisdiction,
+        desired: R2BucketLifecycleRule[],
+      ) =>
+        Effect.gen(function* () {
+          const observed = yield* getBucketLifecycle({
+            accountId,
+            bucketName,
+            jurisdiction,
+          }).pipe(
+            Effect.retry({
+              while: isNoSuchBucket,
+              schedule: r2BucketEndpointConsistencySchedule,
+            }),
+          );
+
+          const observedRules = (observed.rules ?? []).map(toLifecycleRule);
+          const desiredRules = desired.map(normalizeLifecycleRule);
+
+          if (deepEqual(observedRules, desiredRules)) {
+            return desiredRules;
+          }
+
+          yield* putBucketLifecycle({
+            accountId,
+            bucketName,
+            jurisdiction,
+            rules: desired.map(toLifecyclePutPayload),
+          }).pipe(
+            Effect.retry({
+              while: isNoSuchBucket,
+              schedule: r2BucketEndpointConsistencySchedule,
+            }),
+          );
+
+          return desiredRules;
+        });
+
       return {
         stables: ["bucketName", "accountId"],
         diff: Effect.fn(function* ({ id, olds = {}, news = {}, output }) {
@@ -412,6 +618,9 @@ export const R2BucketProvider = () =>
           if (!deepEqual(olds.domains, news.domains)) {
             return { action: "update" } as const;
           }
+          if (!deepEqual(olds.lifecycleRules, news.lifecycleRules)) {
+            return { action: "update" } as const;
+          }
         }),
         reconcile: Effect.fn(function* ({ id, news = {}, output }) {
           const name = yield* createBucketName(id, news.name);
@@ -481,9 +690,16 @@ export const R2BucketProvider = () =>
             output?.domains ?? [],
           );
 
+          const lifecycleRules = yield* reconcileLifecycleRules(
+            attrs.bucketName,
+            attrs.jurisdiction,
+            news.lifecycleRules ?? [],
+          );
+
           return {
             ...attrs,
             domains,
+            lifecycleRules,
           };
         }),
         delete: Effect.fn(function* ({ output }) {
@@ -497,6 +713,7 @@ export const R2BucketProvider = () =>
               Effect.catchIf(isMissingCustomDomainOrBucket, () => Effect.void),
             );
           }
+          yield* emptyBucket(output.bucketName, output.jurisdiction);
           yield* deleteBucket({
             accountId: output.accountId,
             bucketName: output.bucketName,
@@ -519,6 +736,7 @@ export const R2BucketProvider = () =>
               location: normalizeLocation(bucket.location),
               accountId: acct,
               domains: output?.domains ?? [],
+              lifecycleRules: output?.lifecycleRules ?? [],
             })),
             Effect.catchTag("NoSuchBucket", () => Effect.succeed(undefined)),
           );
@@ -527,10 +745,11 @@ export const R2BucketProvider = () =>
     }),
   );
 
-// R2 can make a newly-created bucket visible to `getBucket` before the custom
-// domain endpoints accept it. Retry only that narrow `NoSuchBucket` lag here;
-// not-found domains are still treated as terminal for idempotent deletes.
-const r2CustomDomainConsistencySchedule = Schedule.exponential(100).pipe(
+// R2 can make a newly-created bucket visible to `getBucket` before its
+// sub-resource endpoints (custom domains, lifecycle) accept it. Retry only
+// that narrow `NoSuchBucket` lag here; not-found sub-resources are still
+// treated as terminal for idempotent deletes.
+const r2BucketEndpointConsistencySchedule = Schedule.exponential(100).pipe(
   Schedule.both(Schedule.recurs(5)),
 );
 
@@ -573,6 +792,51 @@ const isMissingCustomDomainOrBucket = (error: unknown): boolean =>
       ((error as { _tag: unknown })._tag === "DomainNotFound" ||
         (error as { _tag: unknown })._tag === "NoSuchBucket")));
 
+type LifecycleRuleResponse = NonNullable<
+  r2.GetBucketLifecycleResponse["rules"]
+>[number];
+
+const toLifecycleRule = (
+  rule: LifecycleRuleResponse,
+): R2Bucket.LifecycleRule => ({
+  id: rule.id,
+  enabled: rule.enabled,
+  prefix: rule.conditions.prefix ?? "",
+  abortMultipartUploadsTransition: rule.abortMultipartUploadsTransition
+    ? { condition: rule.abortMultipartUploadsTransition.condition ?? undefined }
+    : undefined,
+  deleteObjectsTransition: rule.deleteObjectsTransition
+    ? { condition: rule.deleteObjectsTransition.condition ?? undefined }
+    : undefined,
+  storageClassTransitions: rule.storageClassTransitions ?? undefined,
+});
+
+const normalizeLifecycleRule = (
+  rule: R2BucketLifecycleRule,
+): R2Bucket.LifecycleRule => ({
+  id: rule.id,
+  enabled: rule.enabled ?? true,
+  prefix: rule.prefix ?? "",
+  abortMultipartUploadsTransition: rule.abortMultipartUploadsTransition
+    ? { condition: rule.abortMultipartUploadsTransition.condition }
+    : undefined,
+  deleteObjectsTransition: rule.deleteObjectsTransition
+    ? { condition: rule.deleteObjectsTransition.condition }
+    : undefined,
+  storageClassTransitions: rule.storageClassTransitions,
+});
+
+const toLifecyclePutPayload = (
+  rule: R2BucketLifecycleRule,
+): NonNullable<r2.PutBucketLifecycleRequest["rules"]>[number] => ({
+  id: rule.id,
+  enabled: rule.enabled ?? true,
+  conditions: { prefix: rule.prefix ?? "" },
+  abortMultipartUploadsTransition: rule.abortMultipartUploadsTransition,
+  deleteObjectsTransition: rule.deleteObjectsTransition,
+  storageClassTransitions: rule.storageClassTransitions,
+});
+
 const isNoSuchBucket = (error: unknown): boolean =>
   typeof error === "object" &&
   error !== null &&