alchemy 2.0.0-beta.35 → 2.0.0-beta.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-beta.35",
+  "version": "2.0.0-beta.36",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",
@@ -309,6 +309,7 @@
     "react": "^19.2.0",
     "rolldown": "1.0.0-rc.17",
     "sonda": "^0.11.1",
+    "undici": "^7.16.0",
     "web-tree-sitter": "0.25.10",
     "yaml": "^2.0.0"
   },

package/src/Cli/main.ts

@@ -8,9 +8,12 @@ import { AlchemyContextLive } from "alchemy/AlchemyContext";
 import { CredentialsStoreLive } from "alchemy/Auth/Credentials";
 import { ProfileLive } from "alchemy/Auth/Profile";
 import { TelemetryLive } from "alchemy/Telemetry/Layer";
+import { installLocalhostDns } from "alchemy/Util/LocalhostDns";
 import { PlatformServices } from "alchemy/Util/PlatformServices";
 import packageJson from "../../package.json" with { type: "json" };
 
+installLocalhostDns();
+
 import { checkLatestVersion } from "./checkVersion.ts";
 import { handleCancellation } from "./commands/_shared.ts";
 import { awsCommand } from "./commands/aws.ts";

package/src/Cloudflare/Images/Images.ts

@@ -0,0 +1,121 @@
+import * as Effect from "effect/Effect";
+import { ImagesBinding } 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.
+   *
+   * @default "IMAGES"
+   */
+  name?: string;
+};
+
+/**
+ * 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.
+ */
+export type Images = {
+  kind: ImagesTypeId;
+  name: string;
+};
+
+export const isImages = (value: unknown): value is Images =>
+  typeof value === "object" &&
+  value !== null &&
+  "kind" in value &&
+  (value as Images).kind === ImagesTypeId;
+
+/**
+ * A Cloudflare Images binding for image transformation and manipulation inside
+ * Workers.
+ *
+ * The Effect-native interface (`Cloudflare.Images.bind(...)`) returns an
+ * `ImagesClient` whose methods take Effect `Stream.Stream<Uint8Array>`
+ * inputs and return `Effect`s — `info`, `input(...).transform(...)
+ * .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
+ * import { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
+ *
+ * Cloudflare.Worker("ImageWorker", { main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     const pipeline = yield* Pipeline;
+ *     const images = yield* Cloudflare.Images.bind(pipeline);
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const request = yield* HttpServerRequest;
+ *         // request.stream is Stream.Stream<Uint8Array>
+ *         const info = yield* images.info(request.stream);
+ *         return yield* HttpServerResponse.json(info);
+ *       }),
+ *     };
+ *   }).pipe(Effect.provide(Cloudflare.ImagesBindingLive)),
+ * );
+ * ```
+ *
+ * @example Transform an image — chainable pipeline, single Effect at the end
+ * ```typescript
+ * const result = yield* (yield* images.input(request.stream))
+ *   .transform({ width: 128 })
+ *   .output({ format: "image/jpeg" });
+ *
+ * const response = yield* result.response;
+ * ```
+ *
+ * @section Binding to a Worker (declarative)
+ * @example
+ * ```typescript
+ * export const Worker = Cloudflare.Worker("Worker", {
+ *   main: "./src/worker.ts",
+ *   bindings: { MEDIA: Pipeline },
+ * });
+ *
+ * export type WorkerEnv = Cloudflare.InferEnv<typeof Worker>;
+ * //   { MEDIA: ImagesBinding }
+ * ```
+ *
+ * Inside the Worker, the raw Cloudflare runtime binding is reachable via
+ * `client.raw` if you need to call `info()` / `input()` directly with
+ * `async`/`await`. The Effect-native interface is preferred — it returns
+ * tagged `ImagesError`s, threads `WorkerEnvironment`, and lets you stream
+ * Effect `Stream<Uint8Array>` sources without manual conversion.
+ *
+ * @see https://developers.cloudflare.com/images/transform-images/bindings/
+ */
+export const Images: {
+  (props?: ImagesProps): Effect.Effect<Images>;
+  /**
+   * Bind Cloudflare Images to the surrounding Worker, returning an
+   * Effect-native client with access to the native Workers runtime binding.
+   */
+  bind: typeof ImagesBinding.bind;
+} = Object.assign(
+  Effect.fn(function* (props?: ImagesProps) {
+    return {
+      kind: ImagesTypeId,
+      name: props?.name ?? "IMAGES",
+    } satisfies Images;
+  }),
+  {
+    bind: (...args: Parameters<typeof ImagesBinding.bind>) =>
+      ImagesBinding.bind(...args),
+  },
+);

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/Providers.ts

@@ -21,6 +21,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";
@@ -56,6 +57,7 @@ export const providers = () =>
       D1.D1Database,
       Hyperdrive.Hyperdrive,
       Hyperdrive.HyperdriveBindingPolicy,
+      Images.ImagesBindingPolicy,
       KV.KVNamespace,
       KV.KVNamespaceBindingPolicy,
       Queue.Queue,
@@ -88,6 +90,7 @@ export const providers = () =>
         D1.DatabaseProvider(),
         Hyperdrive.HyperdriveBindingPolicyLive,
         Hyperdrive.HyperdriveProvider(),
+        Images.ImagesBindingPolicyLive,
         KV.KVNamespaceBindingPolicyLive,
         KV.KVNamespaceProvider(),
         Queue.QueueBindingPolicyLive,