alchemy 2.0.0-beta.34 → 2.0.0-beta.36

package/src/Cloudflare/CloudflareEnvironment.ts

@@ -4,7 +4,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import { getAuthProvider } from "../Auth/AuthProvider.ts";
-import { ALCHEMY_PROFILE, loadOrConfigure } from "../Auth/Profile.ts";
+import { ALCHEMY_PROFILE, Profile } from "../Auth/Profile.ts";
 import {
   CLOUDFLARE_AUTH_PROVIDER_NAME,
   type CloudflareAuthConfig,
@@ -34,6 +34,7 @@ export const fromProfile = () =>
   Layer.effect(
     CloudflareEnvironment,
     Effect.gen(function* () {
+      const profile = yield* Profile;
       const auth = yield* getAuthProvider<
         CloudflareAuthConfig,
         CloudflareResolvedCredentials
@@ -43,7 +44,7 @@ export const fromProfile = () =>
       // `loadOrConfigure` reads the persisted config under the canonical
       // provider name (`Cloudflare`); only runs `configure` (and persists the
       // result) if no stored config exists.
-      const config = yield* loadOrConfigure(auth, profileName, { ci });
+      const config = yield* profile.loadOrConfigure(auth, profileName, { ci });
       return yield* auth.read(profileName, config as CloudflareAuthConfig);
     }),
   );

package/src/Cloudflare/Credentials.ts

@@ -11,7 +11,7 @@ import * as Layer from "effect/Layer";
 import * as Match from "effect/Match";
 import * as Redacted from "effect/Redacted";
 import { getAuthProvider } from "../Auth/AuthProvider.ts";
-import { ALCHEMY_PROFILE, loadOrConfigure } from "../Auth/Profile.ts";
+import { ALCHEMY_PROFILE, Profile } from "../Auth/Profile.ts";
 import {
   CLOUDFLARE_AUTH_PROVIDER_NAME,
   type CloudflareAuthConfig,
@@ -29,15 +29,15 @@ export const fromAuthProvider = () =>
   Layer.effect(
     Credentials,
     Effect.gen(function* () {
+      const profile = yield* Profile;
       const auth = yield* getAuthProvider<
         CloudflareAuthConfig,
         CloudflareResolvedCredentials
       >(CLOUDFLARE_AUTH_PROVIDER_NAME);
       const profileName = yield* ALCHEMY_PROFILE;
       const ci = yield* Config.boolean("CI").pipe(Config.withDefault(false));
-      const ctx = yield* Effect.context<never>();
 
-      return loadOrConfigure(auth, profileName, { ci }).pipe(
+      return profile.loadOrConfigure(auth, profileName, { ci }).pipe(
         Effect.flatMap((config) =>
           auth.read(profileName, config as CloudflareAuthConfig),
         ),
@@ -69,7 +69,6 @@ export const fromAuthProvider = () =>
               message: `Failed to resolve Cloudflare credentials for profile '${profileName}': ${(e as { message?: string }).message ?? String(e)}`,
             }),
         ),
-        Effect.provide(ctx),
       );
     }),
   );

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/Local/Sidecar.ts

@@ -1,7 +1,4 @@
-import {
-  ServeError,
-  type ServeResult,
-} from "@distilled.cloud/cloudflare-runtime/Server";
+import { RuntimeError } from "@distilled.cloud/cloudflare-runtime/RuntimeError";
 import * as Worker from "@distilled.cloud/cloudflare-runtime/Worker";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
@@ -22,13 +19,19 @@ export interface ServeOptions extends WorkerBundleOptions {
   durableObjectNamespaces: Worker.DurableObjectNamespace[];
 }
 
+export const ServeResult = Schema.Struct({
+  name: Schema.String,
+  address: Schema.String,
+});
+export type ServeResult = typeof ServeResult.Type;
+
+export const ServeError = Schema.Union([RuntimeError, BundleError]);
+export type ServeError = typeof ServeError.Type;
+
 export const SidecarSchema = defineSchema<Sidecar["Service"]>({
   serve: {
-    success: Schema.Struct({
-      name: Schema.String,
-      address: Schema.String,
-    }),
-    error: Schema.Union([ServeError, BundleError]),
+    success: ServeResult,
+    error: ServeError,
   },
   stop: { success: Schema.Void, error: Schema.Never },
 });
@@ -38,7 +41,7 @@ export class Sidecar extends RpcClient.RpcClientService<
   {
     readonly serve: (
       options: ServeOptions,
-    ) => Effect.Effect<ServeResult, ServeError | BundleError>;
+    ) => Effect.Effect<ServeResult, ServeError>;
     readonly stop: (name: string) => Effect.Effect<void>;
   }
 >()("Sidecar") {}

package/src/Cloudflare/Local/SidecarHandlers.ts

@@ -12,7 +12,12 @@ import * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
 import * as Bundle from "../../Bundle/Bundle.ts";
 import { WorkerBundle } from "../Workers/WorkerBundle.ts";
-import { Sidecar, type ServeOptions } from "./Sidecar.ts";
+import {
+  Sidecar,
+  type ServeError,
+  type ServeOptions,
+  type ServeResult,
+} from "./Sidecar.ts";
 
 export const SidecarHandlers = Layer.effect(
   Sidecar,
@@ -29,10 +34,6 @@ export const SidecarHandlers = Layer.effect(
     ) {
       const scope = yield* Effect.flatMap(Effect.scope, Scope.fork);
       const result = yield* server
-        // The published @distilled.cloud/cloudflare-runtime types don't yet
-        // declare `hyperdrives` on the serve options, but the runtime
-        // accepts it. Cast through any so dev-mode local DB wiring works
-        // until the type is shipped upstream.
         .serve({
           name: worker.id.toLowerCase(),
           compatibilityDate: worker.compatibility.date,
@@ -55,19 +56,13 @@ export const SidecarHandlers = Layer.effect(
       string,
       {
         hash: number;
-        fiber: Fiber.Fiber<
-          Server.ServeResult,
-          Server.ServeError | Bundle.BundleError
-        >;
+        fiber: Fiber.Fiber<ServeResult, ServeError>;
         scope: Scope.Closeable;
       }
     >();
 
     const serveFiber = Effect.fnUntraced(function* (worker: ServeOptions) {
-      const result = yield* Deferred.make<
-        Server.ServeResult,
-        Server.ServeError | Bundle.BundleError
-      >();
+      const result = yield* Deferred.make<ServeResult, ServeError>();
       let start = Date.now();
       yield* bundle.watch(worker).pipe(
         Stream.mapEffect((event) =>

package/src/Cloudflare/Local/SidecarServer.ts

@@ -5,7 +5,10 @@ import * as Path from "effect/Path";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import * as AlchemyContext from "../../AlchemyContext.ts";
 import { AuthProviders } from "../../Auth/AuthProvider.ts";
+import { CredentialsStoreLive } from "../../Auth/Credentials.ts";
+import { ProfileLive } from "../../Auth/Profile.ts";
 import * as RpcServer from "../../Sidecar/RpcServer.ts";
+import * as RpcServices from "../../Sidecar/RpcServices.ts";
 import {
   httpServer,
   PlatformServices,
@@ -23,6 +26,8 @@ const apiServices = Layer.merge(
 ).pipe(
   Layer.provide(CloudflareAuth),
   Layer.provide(Layer.succeed(AuthProviders, {})),
+  Layer.provide(ProfileLive),
+  Layer.provide(CredentialsStoreLive),
 );
 
 const runtimeServices = SidecarHandlers.pipe(
@@ -46,7 +51,7 @@ const runtimeServices = SidecarHandlers.pipe(
 );
 
 const services = Layer.provideMerge(
-  Layer.provideMerge(runtimeServices, RpcServer.layerServices(import.meta.url)),
+  Layer.provideMerge(runtimeServices, RpcServices.layer(import.meta.url)),
   PlatformServices,
 );
 

package/src/Cloudflare/Logs.ts

@@ -1,6 +1,10 @@
 import * as workers from "@distilled.cloud/cloudflare/workers";
+import type * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Schedule from "effect/Schedule";
 import * as Stream from "effect/Stream";
+import * as Socket from "effect/unstable/socket/Socket";
 import type { LogLine, LogsInput } from "../Provider.ts";
 
 const DEFAULT_LOOKBACK_MS = 1 * 60 * 60 * 1000;
@@ -23,6 +27,33 @@ export interface TelemetryFilter {
   value?: string | number | boolean;
 }
 
+interface TailEventMessage {
+  eventTimestamp?: number;
+  wallTime: number;
+  cpuTime: number;
+  truncated: boolean;
+  outcome: string;
+  scriptName: string;
+  exceptions: {
+    name: string;
+    message: string;
+    stack: string;
+    timestamp: string;
+  }[];
+  logs: {
+    message: string[];
+    level: string;
+    timestamp: string;
+  }[];
+  event:
+    | {
+        request: { method: string; url: string };
+        response?: { status: number };
+      }
+    | null
+    | undefined;
+}
+
 const parseEvents = (
   response: workers.QueryObservabilityTelemetryResponse,
 ): LogLine[] => {
@@ -44,6 +75,8 @@ const parseEvents = (
 
 export const CloudflareLogs = Effect.gen(function* () {
   const queryTelemetry = yield* workers.queryObservabilityTelemetry;
+  const createScriptTail = yield* workers.createScriptTail;
+  const deleteScriptTail = yield* workers.deleteScriptTail;
 
   const queryLogs = (opts: {
     accountId: string;
@@ -83,6 +116,87 @@ export const CloudflareLogs = Effect.gen(function* () {
       return parseEvents(response);
     });
 
+  /**
+   * Open a real-time Workers tail session against `scriptName` and
+   * surface its messages as a {@link LogLine} stream. The websocket is
+   * automatically reconnected (with `Stream.repeat`) when Cloudflare
+   * closes it after its idle window.
+   */
+  const tailScript = (opts: { accountId: string; scriptName: string }) => {
+    const runTailSession = Effect.gen(function* () {
+      const { id: tailId, url } = yield* createScriptTail({
+        scriptName: opts.scriptName,
+        accountId: opts.accountId,
+        body: { filters: [] },
+      });
+
+      const socket = yield* Socket.makeWebSocket(url, {
+        protocols: ["trace-v1"],
+      });
+
+      const queue = yield* Queue.make<LogLine, Cause.Done>();
+
+      yield* socket
+        .runRaw((raw) => {
+          const text =
+            typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+          const data: TailEventMessage = JSON.parse(text);
+          const eventTs = new Date(data.eventTimestamp ?? Date.now());
+
+          if (data.event && "request" in data.event) {
+            const reqEvent = data.event;
+            const pathname = (() => {
+              try {
+                return new URL(reqEvent.request.url).pathname;
+              } catch {
+                return reqEvent.request.url;
+              }
+            })();
+            const status = reqEvent.response?.status ?? 500;
+            Queue.offerUnsafe(queue, {
+              timestamp: eventTs,
+              message: `${reqEvent.request.method} ${pathname} > ${status} (cpu: ${Math.round(data.cpuTime)}ms, wall: ${Math.round(data.wallTime)}ms)`,
+            });
+          }
+
+          for (const log of data.logs) {
+            const msg = log.message.join(" ");
+            Queue.offerUnsafe(queue, {
+              timestamp: new Date(log.timestamp),
+              message: log.level === "log" ? msg : `${log.level}: ${msg}`,
+            });
+          }
+
+          for (const exception of data.exceptions) {
+            Queue.offerUnsafe(queue, {
+              timestamp: new Date(exception.timestamp),
+              message: `${exception.name} ${exception.message}\n${exception.stack}`,
+            });
+          }
+        })
+        .pipe(
+          Effect.ensuring(
+            Effect.all([
+              deleteScriptTail({
+                scriptName: opts.scriptName,
+                id: tailId,
+                accountId: opts.accountId,
+              }).pipe(Effect.ignore),
+              Queue.end(queue),
+            ]),
+          ),
+          Effect.ignore,
+          Effect.forkChild(),
+        );
+
+      return Stream.fromQueue(queue);
+    });
+
+    return Stream.unwrap(runTailSession).pipe(
+      Stream.repeat(Schedule.spaced("1 second")),
+    );
+  };
+
   const tailStream = (opts: {
     accountId: string;
     filters: TelemetryFilter[];
@@ -118,5 +232,5 @@ export const CloudflareLogs = Effect.gen(function* () {
     return poll(Date.now());
   };
 
-  return { queryLogs, tailStream };
+  return { queryLogs, tailScript, tailStream };
 });

package/src/Cloudflare/Providers.ts

@@ -8,6 +8,8 @@ import * as Schedule from "effect/Schedule";
 import { Command } from "../Build/Command.ts";
 import * as Build from "../Build/index.ts";
 import * as Provider from "../Provider.ts";
+import { CredentialsStoreLive } from "../Auth/Credentials.ts";
+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";
@@ -19,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";
@@ -54,11 +57,13 @@ export const providers = () =>
       D1.D1Database,
       Hyperdrive.Hyperdrive,
       Hyperdrive.HyperdriveBindingPolicy,
+      Images.ImagesBindingPolicy,
       KV.KVNamespace,
       KV.KVNamespaceBindingPolicy,
       Queue.Queue,
       Queue.QueueBindingPolicy,
       Queue.QueueConsumer,
+      Queue.QueueEventSourcePolicy,
       R2.R2Bucket,
       R2.R2BucketBindingPolicy,
       SecretsStore.SecretBindingPolicy,
@@ -85,9 +90,11 @@ export const providers = () =>
         D1.DatabaseProvider(),
         Hyperdrive.HyperdriveBindingPolicyLive,
         Hyperdrive.HyperdriveProvider(),
+        Images.ImagesBindingPolicyLive,
         KV.KVNamespaceBindingPolicyLive,
         KV.KVNamespaceProvider(),
         Queue.QueueBindingPolicyLive,
+        Queue.QueueEventSourcePolicyLive,
         Queue.QueueProvider(),
         Queue.QueueConsumerProvider(),
         R2.R2BucketBindingPolicyLive,
@@ -110,6 +117,8 @@ export const providers = () =>
     Layer.provideMerge(CloudflareEnvironment.fromProfile()),
     Layer.provideMerge(CloudflareAuth),
     Layer.provideMerge(Access.AccessLive),
+    Layer.provideMerge(ProfileLive),
+    Layer.provideMerge(CredentialsStoreLive),
     // Apply a blanket retry policy to every Cloudflare API call. Extends
     // `Retry.makeDefault`'s transient detection (throttling / 5xx /
     // network) with one Cloudflare-specific misleadingly-tagged