alchemy 2.0.0-beta.47 → 2.0.0-beta.49

package/src/Cloudflare/Dns/DnsRead.ts

@@ -0,0 +1,129 @@
+import type {
+  GetRecordError,
+  GetRecordResponse,
+  ListRecordsError,
+  ListRecordsRequest,
+  ListRecordsResponse,
+} from "@distilled.cloud/cloudflare/dns";
+import * as dns from "@distilled.cloud/cloudflare/dns";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
+import type { AccountApiToken } from "../ApiToken/AccountApiToken.ts";
+import type { Zone } from "../Zone/Zone.ts";
+import {
+  authorizeDns,
+  type DnsToken,
+  makeDnsClient,
+  makeDnsPolicyLive,
+} from "./DnsBinding.ts";
+
+/** List-records request, minus the zone id (bound at `.bind(zone)` time). */
+export type ListRecordsRequestInput = Omit<ListRecordsRequest, "zoneId">;
+
+/**
+ * Read-only DNS record operations. Backed by the `DNS Read` permission group.
+ * The zone is fixed when the client is bound, so no `zoneId` is passed per call.
+ */
+export interface DnsReadClient {
+  /** Fetch a single DNS record by id. */
+  getDnsRecord(
+    dnsRecordId: string,
+  ): Effect.Effect<GetRecordResponse, GetRecordError, RuntimeContext>;
+  /** List the DNS records in the bound zone. */
+  listDnsRecords(
+    request?: ListRecordsRequestInput,
+  ): Effect.Effect<ListRecordsResponse, ListRecordsError, RuntimeContext>;
+}
+
+/** Build the read-only client over a bound token and zone id. */
+export const dnsReadClient = (
+  token: DnsToken,
+  zoneId: Effect.Effect<string>,
+): DnsReadClient => {
+  const authorize = authorizeDns(token);
+  return {
+    getDnsRecord: Effect.fn("Cloudflare.Dns.getDnsRecord")(
+      function* (dnsRecordId) {
+        return yield* authorize(
+          dns.getRecord({ zoneId: yield* zoneId, dnsRecordId }),
+        );
+      },
+    ),
+    listDnsRecords: Effect.fn("Cloudflare.Dns.listDnsRecords")(
+      function* (request) {
+        return yield* authorize(
+          dns.listRecords({ zoneId: yield* zoneId, ...request }),
+        );
+      },
+    ),
+  };
+};
+
+/**
+ * Binding that lets a Worker read Cloudflare DNS records at runtime.
+ *
+ * Creates a least-privilege {@link AccountApiToken} with only the `DNS Read`
+ * permission, scoped to the single zone passed to `bind`, and binds its value
+ * into the Worker so runtime code can authenticate.
+ *
+ * @binding
+ *
+ * @section Reading DNS records at runtime
+ * @example Read records from inside a Worker
+ * Bind the client in the Worker's Init phase and provide {@link DnsReadLive}.
+ * The zone is fixed by `.bind(zone)` — the provisioned token only grants
+ * access to that zone, so calls take no `zoneId`. Pass the {@link Zone}
+ * resource directly (it's an `Effect`), or `yield* Zone` for a resolved value.
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ * import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+ *
+ * const Zone = Cloudflare.Zone("MyZone", { name: "example.com" });
+ *
+ * export class DnsReaderWorker extends Cloudflare.Worker<DnsReaderWorker>()(
+ *   "DnsReaderWorker",
+ *   { main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     // Init phase — bind the read client scoped to the zone.
+ *     const dns = yield* Cloudflare.DnsRead.bind(Zone);
+ *
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const { result } = yield* dns.listDnsRecords({ type: "A" });
+ *         const record = yield* dns.getDnsRecord(result[0].id);
+ *         return yield* HttpServerResponse.json({ id: record.id });
+ *       }),
+ *     };
+ *   }).pipe(Effect.provide(Cloudflare.DnsReadLive)),
+ * ) {}
+ * ```
+ */
+export class DnsRead extends Binding.Service<
+  DnsRead,
+  (zone: Zone) => Effect.Effect<DnsReadClient>
+>()("Cloudflare.DnsRead") {}
+
+/**
+ * Deploy-time policy for {@link DnsRead}. Attaches the `DNS Read` permission to
+ * the token via its binding contract.
+ */
+export class DnsReadPolicy extends Binding.Policy<
+  DnsReadPolicy,
+  (token: AccountApiToken, zone: Zone) => Effect.Effect<void>
+>()("Cloudflare.DnsRead") {}
+
+/** Runtime layer for {@link DnsRead}. */
+export const DnsReadLive = Layer.effect(
+  DnsRead,
+  makeDnsClient(DnsReadPolicy, "DnsReadToken", dnsReadClient),
+);
+
+/** Live deploy-time policy layer for {@link DnsReadPolicy}. */
+export const DnsReadPolicyLive = makeDnsPolicyLive(
+  DnsReadPolicy,
+  "Cloudflare.DnsRead",
+  ["DNS Read"],
+);

package/src/Cloudflare/Dns/DnsReadWrite.ts

@@ -0,0 +1,99 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import type { AccountApiToken } from "../ApiToken/AccountApiToken.ts";
+import type { Zone } from "../Zone/Zone.ts";
+import {
+  type DnsToken,
+  makeDnsClient,
+  makeDnsPolicyLive,
+} from "./DnsBinding.ts";
+import { dnsReadClient, type DnsReadClient } from "./DnsRead.ts";
+import { dnsWriteClient, type DnsWriteClient } from "./DnsWrite.ts";
+
+/** Combined read + write DNS record operations. */
+export interface DnsReadWriteClient extends DnsReadClient, DnsWriteClient {}
+
+/** Build the combined read + write client over a bound token and zone id. */
+export const dnsReadWriteClient = (
+  token: DnsToken,
+  zoneId: Effect.Effect<string>,
+): DnsReadWriteClient => ({
+  ...dnsReadClient(token, zoneId),
+  ...dnsWriteClient(token, zoneId),
+});
+
+/**
+ * Binding that lets a Worker perform the full Cloudflare DNS record CRUD
+ * surface at runtime.
+ *
+ * Creates a least-privilege {@link AccountApiToken} with both the `DNS Read`
+ * and `DNS Write` permissions, scoped to the single zone passed to `bind`, and
+ * binds its value into the Worker so runtime code can authenticate.
+ *
+ * @binding
+ *
+ * @section Managing DNS records at runtime
+ * @example Full CRUD from inside a Worker
+ * Bind the client in the Worker's Init phase and provide
+ * {@link DnsReadWriteLive}. The zone is fixed by `.bind(zone)` — the
+ * provisioned token only grants access to that zone, so calls take no
+ * `zoneId`. Pass the {@link Zone} resource directly (it's an `Effect`), or
+ * `yield* Zone` for a resolved value.
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ * import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+ *
+ * const Zone = Cloudflare.Zone("MyZone", { name: "example.com" });
+ *
+ * export class DnsWorker extends Cloudflare.Worker<DnsWorker>()(
+ *   "DnsWorker",
+ *   { main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     // Init phase — bind the full CRUD client scoped to the zone.
+ *     const dns = yield* Cloudflare.DnsReadWrite.bind(Zone);
+ *
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const { result } = yield* dns.createDnsRecord({
+ *           type: "A",
+ *           name: "app.example.com",
+ *           content: "192.0.2.1",
+ *           ttl: 1,
+ *         });
+ *         const record = yield* dns.getDnsRecord(result.id);
+ *         yield* dns.deleteDnsRecord(result.id);
+ *         return yield* HttpServerResponse.json({ id: record.id });
+ *       }),
+ *     };
+ *   }).pipe(Effect.provide(Cloudflare.DnsReadWriteLive)),
+ * ) {}
+ * ```
+ */
+export class DnsReadWrite extends Binding.Service<
+  DnsReadWrite,
+  (zone: Zone) => Effect.Effect<DnsReadWriteClient>
+>()("Cloudflare.DnsReadWrite") {}
+
+/**
+ * Deploy-time policy for {@link DnsReadWrite}. Attaches both the `DNS Read` and
+ * `DNS Write` permissions to the token via its binding contract.
+ */
+export class DnsReadWritePolicy extends Binding.Policy<
+  DnsReadWritePolicy,
+  (token: AccountApiToken, zone: Zone) => Effect.Effect<void>
+>()("Cloudflare.DnsReadWrite") {}
+
+/** Runtime layer for {@link DnsReadWrite}. */
+export const DnsReadWriteLive = Layer.effect(
+  DnsReadWrite,
+  makeDnsClient(DnsReadWritePolicy, "DnsReadWriteToken", dnsReadWriteClient),
+);
+
+/** Live deploy-time policy layer for {@link DnsReadWritePolicy}. */
+export const DnsReadWritePolicyLive = makeDnsPolicyLive(
+  DnsReadWritePolicy,
+  "Cloudflare.DnsReadWrite",
+  ["DNS Read", "DNS Write"],
+);

package/src/Cloudflare/Dns/DnsWrite.ts

@@ -0,0 +1,209 @@
+import type {
+  BatchRecordError,
+  BatchRecordRequest,
+  BatchRecordResponse,
+  CreateRecordError,
+  CreateRecordRequest,
+  CreateRecordResponse,
+  DeleteRecordError,
+  DeleteRecordResponse,
+  PatchRecordError,
+  PatchRecordRequest,
+  PatchRecordResponse,
+  UpdateRecordError,
+  UpdateRecordRequest,
+  UpdateRecordResponse,
+} from "@distilled.cloud/cloudflare/dns";
+import * as dns from "@distilled.cloud/cloudflare/dns";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
+import type { AccountApiToken } from "../ApiToken/AccountApiToken.ts";
+import type { Zone } from "../Zone/Zone.ts";
+import {
+  authorizeDns,
+  type DnsToken,
+  makeDnsClient,
+  makeDnsPolicyLive,
+} from "./DnsBinding.ts";
+
+/** Create-record request, minus the zone id (bound at `.bind(zone)` time). */
+export type CreateRecordRequestInput = Omit<CreateRecordRequest, "zoneId">;
+
+/** Update-record request, minus the zone id and record id. */
+export type UpdateRecordRequestInput = Omit<
+  UpdateRecordRequest,
+  "zoneId" | "dnsRecordId"
+>;
+
+/** Patch-record request, minus the zone id and record id. */
+export type PatchRecordRequestInput = Omit<
+  PatchRecordRequest,
+  "zoneId" | "dnsRecordId"
+>;
+
+/** Batch-records request, minus the zone id (bound at `.bind(zone)` time). */
+export type BatchRecordRequestInput = Omit<BatchRecordRequest, "zoneId">;
+
+/**
+ * Mutating DNS record operations. Backed by the `DNS Write` permission group.
+ * The zone is fixed when the client is bound, so no `zoneId` is passed per call.
+ */
+export interface DnsWriteClient {
+  /** Create a DNS record. */
+  createDnsRecord(
+    request: CreateRecordRequestInput,
+  ): Effect.Effect<CreateRecordResponse, CreateRecordError, RuntimeContext>;
+  /** Overwrite (PUT) a DNS record. */
+  updateDnsRecord(
+    dnsRecordId: string,
+    request: UpdateRecordRequestInput,
+  ): Effect.Effect<UpdateRecordResponse, UpdateRecordError, RuntimeContext>;
+  /** Partially update (PATCH) a DNS record. */
+  patchDnsRecord(
+    dnsRecordId: string,
+    request: PatchRecordRequestInput,
+  ): Effect.Effect<PatchRecordResponse, PatchRecordError, RuntimeContext>;
+  /** Delete a DNS record by id. */
+  deleteDnsRecord(
+    dnsRecordId: string,
+  ): Effect.Effect<DeleteRecordResponse, DeleteRecordError, RuntimeContext>;
+  /** Apply a batch of create / update / patch / delete operations atomically. */
+  batchDnsRecords(
+    request: BatchRecordRequestInput,
+  ): Effect.Effect<BatchRecordResponse, BatchRecordError, RuntimeContext>;
+}
+
+/** Build the write client over a bound token and zone id. */
+export const dnsWriteClient = (
+  token: DnsToken,
+  zoneId: Effect.Effect<string>,
+): DnsWriteClient => {
+  const authorize = authorizeDns(token);
+  return {
+    createDnsRecord: Effect.fn("Cloudflare.Dns.createDnsRecord")(
+      function* (request) {
+        return yield* authorize(
+          dns.createRecord({ zoneId: yield* zoneId, ...request }),
+        );
+      },
+    ),
+    updateDnsRecord: Effect.fn("Cloudflare.Dns.updateDnsRecord")(
+      function* (dnsRecordId, request) {
+        return yield* authorize(
+          dns.updateRecord({ zoneId: yield* zoneId, dnsRecordId, ...request }),
+        );
+      },
+    ),
+    patchDnsRecord: Effect.fn("Cloudflare.Dns.patchDnsRecord")(
+      function* (dnsRecordId, request) {
+        return yield* authorize(
+          dns.patchRecord({ zoneId: yield* zoneId, dnsRecordId, ...request }),
+        );
+      },
+    ),
+    deleteDnsRecord: Effect.fn("Cloudflare.Dns.deleteDnsRecord")(
+      function* (dnsRecordId) {
+        return yield* authorize(
+          dns.deleteRecord({ zoneId: yield* zoneId, dnsRecordId }),
+        );
+      },
+    ),
+    batchDnsRecords: Effect.fn("Cloudflare.Dns.batchDnsRecords")(
+      function* (request) {
+        return yield* authorize(
+          dns.batchRecord({ zoneId: yield* zoneId, ...request }),
+        );
+      },
+    ),
+  };
+};
+
+/**
+ * Binding that lets a Worker create, update, and delete Cloudflare DNS records
+ * at runtime.
+ *
+ * Creates a least-privilege {@link AccountApiToken} with only the `DNS Write`
+ * permission, scoped to the single zone passed to `bind`, and binds its value
+ * into the Worker so runtime code can authenticate.
+ *
+ * @binding
+ *
+ * @section Mutating DNS records at runtime
+ * @example Create, update, and delete records from inside a Worker
+ * Bind the client in the Worker's Init phase and provide {@link DnsWriteLive}.
+ * The zone is fixed by `.bind(zone)` — the provisioned token only grants
+ * access to that zone, so calls take no `zoneId`. Pass the {@link Zone}
+ * resource directly (it's an `Effect`), or `yield* Zone` for a resolved value.
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ * import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+ *
+ * const Zone = Cloudflare.Zone("MyZone", { name: "example.com" });
+ *
+ * export class DnsWriterWorker extends Cloudflare.Worker<DnsWriterWorker>()(
+ *   "DnsWriterWorker",
+ *   { main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     // Init phase — bind the write client scoped to the zone.
+ *     const dns = yield* Cloudflare.DnsWrite.bind(Zone);
+ *
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const { result } = yield* dns.createDnsRecord({
+ *           type: "A",
+ *           name: "app.example.com",
+ *           content: "192.0.2.1",
+ *           ttl: 1,
+ *           proxied: true,
+ *         });
+ *         yield* dns.updateDnsRecord(result.id, {
+ *           type: "A",
+ *           name: "app.example.com",
+ *           content: "192.0.2.2",
+ *           ttl: 1,
+ *         });
+ *         yield* dns.deleteDnsRecord(result.id);
+ *         return yield* HttpServerResponse.json({ id: result.id });
+ *       }),
+ *     };
+ *   }).pipe(Effect.provide(Cloudflare.DnsWriteLive)),
+ * ) {}
+ * ```
+ *
+ * @example Apply a batch of changes atomically
+ * ```typescript
+ * yield* dns.batchDnsRecords({
+ *   posts: [{ type: "A", name: "a.example.com", content: "192.0.2.1", ttl: 1 }],
+ *   deletes: [{ id: oldRecordId }],
+ * });
+ * ```
+ */
+export class DnsWrite extends Binding.Service<
+  DnsWrite,
+  (zone: Zone) => Effect.Effect<DnsWriteClient>
+>()("Cloudflare.DnsWrite") {}
+
+/**
+ * Deploy-time policy for {@link DnsWrite}. Attaches the `DNS Write` permission
+ * to the token via its binding contract.
+ */
+export class DnsWritePolicy extends Binding.Policy<
+  DnsWritePolicy,
+  (token: AccountApiToken, zone: Zone) => Effect.Effect<void>
+>()("Cloudflare.DnsWrite") {}
+
+/** Runtime layer for {@link DnsWrite}. */
+export const DnsWriteLive = Layer.effect(
+  DnsWrite,
+  makeDnsClient(DnsWritePolicy, "DnsWriteToken", dnsWriteClient),
+);
+
+/** Live deploy-time policy layer for {@link DnsWritePolicy}. */
+export const DnsWritePolicyLive = makeDnsPolicyLive(
+  DnsWritePolicy,
+  "Cloudflare.DnsWrite",
+  ["DNS Write"],
+);

package/src/Cloudflare/Dns/index.ts

@@ -0,0 +1,4 @@
+export * from "./DnsBinding.ts";
+export * from "./DnsRead.ts";
+export * from "./DnsReadWrite.ts";
+export * from "./DnsWrite.ts";

package/src/Cloudflare/Email/EmailRouting.ts

@@ -5,7 +5,7 @@ import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import type { Providers } from "../Providers.ts";
-import { resolveZoneId, type ZoneReference } from "../Zone.ts";
+import { resolveZoneId, type ZoneReference } from "../Zone/index.ts";
 
 export type EmailRoutingStatus =
   | "ready"

package/src/Cloudflare/Email/EmailRule.ts

@@ -5,7 +5,7 @@ import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import type { Providers } from "../Providers.ts";
-import { resolveZoneId, type ZoneReference } from "../Zone.ts";
+import { resolveZoneId, type ZoneReference } from "../Zone/index.ts";
 
 export type EmailMatcher =
   | { type: "all" }
@@ -88,16 +88,16 @@ const normalize = (
     name?: string | null;
     enabled?: boolean | null;
     priority?: number | null;
+    // Distilled widened generated string enums to open unions (`string & {}`);
+    // the runtime values are still the known variants, narrowed below.
     matchers?:
       | {
-          type: "all" | "literal";
-          field?: "to" | null;
+          type: string;
+          field?: string | null;
           value?: string | null;
         }[]
       | null;
-    actions?:
-      | { type: "drop" | "forward" | "worker"; value?: string[] | null }[]
-      | null;
+    actions?: { type: string; value?: string[] | null }[] | null;
   },
   zoneId: string,
 ) => ({

package/src/Cloudflare/Images/Images.ts

@@ -1,32 +1,47 @@
-import * as Effect from "effect/Effect";
-import { ImagesBinding } from "./ImagesBinding.ts";
+import type * as Effect from "effect/Effect";
+import { SingleShotGen } from "effect/Utils";
+import { ImagesBinding, type ImagesClient } from "./ImagesBinding.ts";
 
 type ImagesTypeId = typeof ImagesTypeId;
 const ImagesTypeId = "Cloudflare.Images" as const;
 
 export type ImagesProps = {
   /**
-   * Binding name used when `Cloudflare.Images.bind(images)` attaches Images
-   * from inside a Worker init phase. When Images is passed through
-   * `Worker({ bindings: { ... } })`, the object key remains the binding name.
+   * Binding name used when `Images` is bound from inside a Worker init phase
+   * (`yield* Cloudflare.Images(...)`). When passed through
+   * `Worker({ env: { ... } })`, the object key remains the binding name.
    *
    * @default "IMAGES"
    */
   name?: string;
 };
 
+/**
+ * The Effect yielded when an `Images` marker is used inside a Worker init
+ * phase: it attaches the `images` binding to the surrounding Worker and
+ * resolves to the runtime {@link ImagesClient}.
+ */
+type BindEffect = Effect.Effect<ImagesClient, never, ImagesBinding>;
+
 /**
  * Marker for a Cloudflare Images binding.
  *
- * Images bindings are configured directly on Workers and do not have a
- * standalone provisioning API. The Worker provider sees this object in
- * `bindings: { ... }` and emits the corresponding `{ type: "images" }`
- * metadata binding to the script.
+ * It is a plain data structure (so it can be declared directly on a Worker's
+ * `env`) that is **also** yieldable inside an Effect-native Worker. Yielding it
+ * (`yield* Cloudflare.Images(...)`) attaches the binding to the surrounding
+ * Worker and returns the runtime {@link ImagesClient} — no separate `.bind(...)`
+ * step required.
+ *
+ * The divergence is achieved via `[Symbol.iterator]`: the object is not an
+ * `Effect` (so `InferEnv` resolves it to the native `ImagesBinding` in the
+ * `env` position), but it is iterable as one when `yield*`-ed.
  */
-export type Images = {
+export interface Images {
   kind: ImagesTypeId;
   name: string;
-};
+  asEffect(): BindEffect;
+  [Symbol.iterator](): SingleShotGen<BindEffect, ImagesClient>;
+}
 
 export const isImages = (value: unknown): value is Images =>
   typeof value === "object" &&
@@ -44,12 +59,6 @@ export const isImages = (value: unknown): value is Images =>
  * .draw(...).output(...)`. The runtime conversion to Cloudflare's
  * `ReadableStream` is handled internally.
  *
- * @section Declaring Images
- * @example
- * ```typescript
- * const Pipeline = yield* Cloudflare.Images({ name: "PIPELINE" });
- * ```
- *
  * @section Effect-style Worker (recommended)
  * @example Read image format and dimensions from the request body
  * ```typescript
@@ -57,8 +66,8 @@ export const isImages = (value: unknown): value is Images =>
  *
  * Cloudflare.Worker("ImageWorker", { main: import.meta.filename },
  *   Effect.gen(function* () {
- *     const pipeline = yield* Pipeline;
- *     const images = yield* Cloudflare.Images.bind(pipeline);
+ *     // Attaches the binding to this Worker AND returns the runtime client.
+ *     const images = yield* Cloudflare.Images({ name: "PIPELINE" });
  *     return {
  *       fetch: Effect.gen(function* () {
  *         const request = yield* HttpServerRequest;
@@ -85,7 +94,7 @@ export const isImages = (value: unknown): value is Images =>
  * ```typescript
  * export const Worker = Cloudflare.Worker("Worker", {
  *   main: "./src/worker.ts",
- *   bindings: { MEDIA: Pipeline },
+ *   env: { MEDIA: Cloudflare.Images({ name: "PIPELINE" }) },
  * });
  *
  * export type WorkerEnv = Cloudflare.InferEnv<typeof Worker>;
@@ -101,19 +110,23 @@ export const isImages = (value: unknown): value is Images =>
  * @see https://developers.cloudflare.com/images/transform-images/bindings/
  */
 export const Images: {
-  (props?: ImagesProps): Effect.Effect<Images>;
+  (props?: ImagesProps): Images;
   /**
-   * Bind Cloudflare Images to the surrounding Worker, returning an
-   * Effect-native client with access to the native Workers runtime binding.
+   * Bind an existing `Images` marker to the surrounding Worker, returning the
+   * Effect-native client. Equivalent to `yield* images` — prefer yielding the
+   * marker directly.
    */
   bind: typeof ImagesBinding.bind;
 } = Object.assign(
-  Effect.fn(function* (props?: ImagesProps) {
-    return {
+  (props?: ImagesProps): Images => {
+    const self: Images = {
       kind: ImagesTypeId,
       name: props?.name ?? "IMAGES",
-    } satisfies Images;
-  }),
+      asEffect: () => ImagesBinding.bind(self),
+      [Symbol.iterator]: () => new SingleShotGen(ImagesBinding.bind(self)),
+    };
+    return self;
+  },
   {
     bind: (...args: Parameters<typeof ImagesBinding.bind>) =>
       ImagesBinding.bind(...args),