alchemy 2.0.0-beta.64 → 2.0.0-beta.66

package/src/Cloudflare/Workers/Assets.ts

@@ -110,6 +110,54 @@ const createIgnoreMatcher = (patterns: string[]) => {
   return (file: string) => matcher.ignores(file);
 };
 
+/**
+ * Read the special `_headers` / `_redirects` files from an assets
+ * directory. They are excluded from the upload manifest, but their raw
+ * contents must be sent to Cloudflare in the script metadata's asset
+ * config (`config._headers` / `config._redirects`) for the rules to
+ * apply.
+ *
+ * The directory is optional: a config-only assets object (e.g. Vite's
+ * `assets: { runWorkerFirst: true }`, whose directory is supplied by the
+ * build) has no directory to read, and in `dev` there is no build output at
+ * all. That yields no rules rather than an error.
+ */
+export const readAssetsConfigFiles = Effect.fn(function* (
+  directory: string | undefined,
+) {
+  if (directory === undefined) {
+    return { _headers: undefined, _redirects: undefined };
+  }
+  const path = yield* Path.Path;
+  const resolvedDirectory = path.resolve(directory);
+  const [_headers, _redirects] = yield* Effect.all([
+    maybeReadString(path.join(resolvedDirectory, "_headers")),
+    maybeReadString(path.join(resolvedDirectory, "_redirects")),
+  ]);
+  return { _headers, _redirects };
+});
+
+/**
+ * Merge `_headers` / `_redirects` file contents into an asset config,
+ * producing the config to send in the script-upload metadata. Explicit
+ * `headers` / `redirects` props win over the files.
+ */
+export const mergeAssetsConfigFiles = (
+  config: AssetsConfig | undefined,
+  files: { _headers: string | undefined; _redirects: string | undefined },
+): AssetsConfig | undefined => {
+  const headers = config?.headers ?? files._headers;
+  const redirects = config?.redirects ?? files._redirects;
+  if (headers === undefined && redirects === undefined) {
+    return config;
+  }
+  return {
+    ...config,
+    ...(headers !== undefined ? { headers } : undefined),
+    ...(redirects !== undefined ? { redirects } : undefined),
+  };
+};
+
 export const readAssets = Effect.fn(function* ({
   directory,
   ...config
@@ -193,7 +241,11 @@ export const readAssets = Effect.fn(function* ({
   });
   return {
     directory,
-    config,
+    // Fold the `_headers` / `_redirects` file contents into the config
+    // that gets sent to Cloudflare (`metadata.assets.config`). Merged
+    // *after* hashing so the hash input shape stays stable for
+    // already-deployed workers.
+    config: mergeAssetsConfigFiles(config, { _headers, _redirects }),
     manifest: sortedManifest,
     _headers,
     _redirects,

package/src/Cloudflare/Workers/Compatibility.ts

@@ -24,6 +24,13 @@ const CROSS_REQUEST_PROMISE_RESOLUTION =
 // need to be specified anymore"), so it is only appended for older dates.
 const CROSS_REQUEST_PROMISE_RESOLUTION_DEFAULT_ON = "2024-10-14";
 
+// The compatibility date from which `nodejs_compat` selects the full (v2)
+// Node.js compatibility mode. Older dates get the legacy v1 mode, which
+// lacks APIs the build-side unenv transform relies on (e.g.
+// `process.getBuiltinModule`) — deploying that combination fails at script
+// startup, so the default flag is only applied from this date onward.
+const NODEJS_COMPAT_V2_DATE = "2024-09-23";
+
 export const getCompatibility = (props: WorkerProps) => {
   const userFlags = props.compatibility?.flags ?? [];
   const python = isPythonMain(props.main);
@@ -54,15 +61,28 @@ export const getCompatibility = (props: WorkerProps) => {
       // Required while Python Workers are in open beta — the upload API
       // rejects Python modules without it.
       ...(python ? ["python_workers"] : []),
+      // Every JS Worker gets `nodejs_compat` by default — Effect-native
+      // Workers need it for the bundled Effect runtime, and external Workers
+      // (plain `export default { fetch }` entrypoints, vite builds) routinely
+      // import `node:*` built-ins. Without it the bundle uploads fine but
+      // Cloudflare rejects the script with `No such module "node:crypto"`
+      // (#796). Python Workers don't go through the JS bundler, so they get
+      // no default. An explicit `no_nodejs_compat` opts out — appending
+      // `nodejs_compat` alongside it would send Cloudflare a contradictory
+      // flag pair.
+      ...(python || userFlags.includes("no_nodejs_compat")
+        ? []
+        : props.isExternal
+          ? // ISO dates compare lexically.
+            date >= NODEJS_COMPAT_V2_DATE
+            ? ["nodejs_compat"]
+            : []
+          : ["nodejs_compat"]),
       ...(props.isExternal
         ? []
-        : [
-            "nodejs_compat",
-            // ISO dates compare lexically.
-            ...(date < CROSS_REQUEST_PROMISE_RESOLUTION_DEFAULT_ON
-              ? [CROSS_REQUEST_PROMISE_RESOLUTION]
-              : []),
-          ]),
+        : date < CROSS_REQUEST_PROMISE_RESOLUTION_DEFAULT_ON
+          ? [CROSS_REQUEST_PROMISE_RESOLUTION]
+          : []),
     ].filter((value, index, self) => self.indexOf(value) === index),
   };
 };

package/src/Cloudflare/Workers/DurableObject.ts

@@ -952,6 +952,28 @@ export class DurableObjectScope extends Context.Service<
  * });
  * ```
  *
+ * @section Container-Backed Durable Objects in an Async Worker
+ * A container-backed class is declared by binding a `Cloudflare.Container`
+ * directly in the async Worker's `env` — the Container *is* the Durable
+ * Object binding plus its ContainerApplication. See the Async Workers
+ * section on {@link Container} for the full walkthrough.
+ *
+ * @example A Container binding declares the container-backed class
+ * ```typescript
+ * // `Sandbox` is the container-backed DO class exported by the worker
+ * // script (extends `@cloudflare/containers`' `Container`).
+ * import type { Sandbox } from "./src/worker.ts";
+ *
+ * export const Worker = Cloudflare.Worker("Worker", {
+ *   main: "./src/worker.ts",
+ *   env: {
+ *     Sandbox: Cloudflare.Container<Sandbox>("Sandbox", {
+ *       image: "docker.io/cloudflare/sandbox:0.1.3",
+ *     }),
+ *   },
+ * });
+ * ```
+ *
  * @section Moving a Class Between Workers
  * A Durable Object class can move from one Worker to another with its
  * data intact. The move is always **declared** — a class that disappears

package/src/Cloudflare/Workers/DurableObjectBridge.ts

@@ -9,6 +9,7 @@ import * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
 
 import { HttpServerResponse } from "effect/unstable/http";
+import { buildEventTelemetry } from "../../Telemetry.ts";
 import type {
   DurableObjectExport,
   DurableObjectShape,
@@ -62,7 +63,7 @@ export const makeDurableObjectBridge =
 
         this.#instance = state.blockConcurrencyWhile(() =>
           build((promise) => void (state as any).waitUntil?.(promise)).then(
-            ({ context, export: exported }) => {
+            ({ context, export: exported, telemetry }) => {
               const { constructor, services } = exported;
               const doContext = Layer.succeed(
                 DurableObjectState,
@@ -76,7 +77,12 @@ export const makeDurableObjectBridge =
                 Effect.flatMap((instance) =>
                   instance.pipe(Effect.provide(doContext)),
                 ),
-                Effect.map((instance) => ({ instance, services, context })),
+                Effect.map((instance) => ({
+                  instance,
+                  services,
+                  context,
+                  telemetry,
+                })),
                 Effect.runPromise,
               );
             },
@@ -124,16 +130,25 @@ export const makeDurableObjectBridge =
       ) {
         const scope = Scope.makeUnsafe();
 
-        const { instance, services, context } = await this.#instance;
+        const { instance, services, context, telemetry } = await this.#instance;
 
         return fn(instance)
           .pipe(
             Effect.provide(
-              Layer.succeed(
-                DurableObjectState,
-                fromDurableObjectState(this.#state),
+              Layer.mergeAll(
+                Layer.succeed(
+                  DurableObjectState,
+                  fromDurableObjectState(this.#state),
+                ),
+                Layer.succeed(Scope.Scope, scope),
+                // The configured telemetry exporters, attached to the *call*
+                // scope by `buildEventTelemetry` so buffered telemetry
+                // flushes when the scope closes into `waitUntil` below (the
+                // isolate scope never finalizes on workerd).
+                Layer.effectContext(
+                  buildEventTelemetry(context, scope, telemetry()),
+                ),
               ).pipe(
-                Layer.provideMerge(Layer.succeed(Scope.Scope, scope)),
                 Layer.provideMerge(Layer.succeedContext(services)),
                 Layer.provideMerge(Layer.succeedContext(context)),
               ),
@@ -150,9 +165,13 @@ export const makeDurableObjectBridge =
           .finally(() =>
             isScopeEjected(scope)
               ? undefined
-              : Scope.close(scope, Exit.void).pipe(
-                  Effect.runPromise,
-                  (promise) => this.ctx.waitUntil(promise),
+              : this.ctx.waitUntil(
+                  // Match WorkerBridge: yield one macrotask so the
+                  // HttpMiddleware tracer's late span-end reaches the
+                  // telemetry exporter before the scope's flush finalizer.
+                  new Promise((resolve) => setTimeout(resolve, 0)).then(() =>
+                    Effect.runPromise(Scope.close(scope, Exit.void)),
+                  ),
                 ),
           );
       }

package/src/Cloudflare/Workers/InferEnv.ts

@@ -3,7 +3,11 @@
 import type * as Effect from "effect/Effect";
 import type { Redacted } from "effect/Redacted";
 import type * as Stream from "effect/Stream";
-import type { Rpc } from "../../Rpc.ts";
+import type { Output } from "../../Output.ts";
+// Aliased so the ambient Cloudflare `Rpc` namespace (from
+// @cloudflare/workers-types, referenced above) stays reachable for
+// `Rpc.DurableObjectBranded`.
+import type { Rpc as AlchemyRpc } from "../../Rpc.ts";
 import type { WorkflowLike } from "../Workflows/Workflow.ts";
 // NOTE: import the service modules directly rather than `import * as Cloudflare
 // from "../index.ts"`. Importing the whole Cloudflare barrel here creates a
@@ -13,6 +17,7 @@ import type { WorkflowLike } from "../Workflows/Workflow.ts";
 import type * as AI from "../AI/index.ts";
 import type * as AnalyticsEngine from "../AnalyticsEngine/index.ts";
 import type * as ArtifactsNs from "../Artifacts/index.ts";
+import type { Container } from "../Containers/Container.ts";
 import type * as D1 from "../D1/index.ts";
 import type * as Email from "../Email/index.ts";
 import type * as FlagshipNs from "../Flagship/index.ts";
@@ -42,66 +47,76 @@ export type InferEnv<W> =
         };
 
 export type GetBindingType<T> =
-  T extends Effect.Effect<infer A, infer _E, infer _R>
-    ? GetBindingType<A>
-    : T extends FlagshipNs.App
-      ? Flagship
-      : T extends Assets
-        ? Service
-        : T extends Rpc<infer Shape extends object>
-          ? RpcWireShape<Shape> & Service
-          : T extends D1.Database
-            ? D1Database
-            : T extends R2.Bucket
-              ? R2Bucket
-              : T extends KV.Namespace
-                ? KVNamespace
-                : T extends DispatchNamespaceResource
-                  ? DispatchNamespace
-                  : T extends Queues.Queue
-                    ? Queue<unknown>
-                    : T extends AI.Gateway
-                      ? Ai
-                      : T extends AIBinding
+  // A Container bound in `env` is a container-backed Durable Object class —
+  // the runtime binding is the class's namespace. Must be tested BEFORE the
+  // generic Effect unwrap: a Container declaration is itself an Effect.
+  T extends Container.Decl<any, any, any, any, infer DOShape>
+    ? DurableObjectNamespace<DOShape & Rpc.DurableObjectBranded>
+    : // `Worker.URL` (an Effect resolving to a deferred string accessor) needs
+      // no case of its own: the generic Effect unwrap below reduces it to
+      // `string` via the fallthrough.
+      T extends
+          | Output<infer A, infer _Req>
+          | Effect.Effect<infer A, infer _E, infer _R>
+      ? GetBindingType<A>
+      : T extends FlagshipNs.App
+        ? Flagship
+        : T extends Assets
+          ? Service
+          : T extends AlchemyRpc<infer Shape extends object>
+            ? RpcWireShape<Shape> & Service
+            : T extends D1.Database
+              ? D1Database
+              : T extends R2.Bucket
+                ? R2Bucket
+                : T extends KV.Namespace
+                  ? KVNamespace
+                  : T extends DispatchNamespaceResource
+                    ? DispatchNamespace
+                    : T extends Queues.Queue
+                      ? Queue<unknown>
+                      : T extends AI.Gateway
                         ? Ai
-                        : T extends AI.Search
-                          ? AiSearchInstance
-                          : T extends AI.SearchNamespace
-                            ? AiSearchNamespace
-                            : T extends Email.SendEmail
-                              ? SendEmail
-                              : T extends AnalyticsEngine.Dataset
-                                ? AnalyticsEngineDataset
-                                : T extends ArtifactsNs.Namespace
-                                  ? Artifacts
-                                  : T extends RateLimitBinding
-                                    ? RateLimit
-                                    : T extends ImagesNs.ImagesBinding
-                                      ? ImagesBinding
-                                      : T extends BrowserBinding
-                                        ? BrowserRun
-                                        : T extends HyperdriveNs.Connection
-                                          ? Hyperdrive
-                                          : T extends VersionMetadataBinding
-                                            ? WorkerVersionMetadata
-                                            : T extends WorkerLoaderResource
-                                              ? WorkerLoader
-                                              : T extends WorkflowLike<
-                                                    infer Params
-                                                  >
-                                                ? Workflow<Params>
-                                                : T extends DurableObjectLike
-                                                  ? DurableObjectNamespace<
-                                                      Exclude<
-                                                        T["Shape"],
-                                                        undefined
-                                                      >
+                        : T extends AIBinding
+                          ? Ai
+                          : T extends AI.Search
+                            ? AiSearchInstance
+                            : T extends AI.SearchNamespace
+                              ? AiSearchNamespace
+                              : T extends Email.SendEmail
+                                ? SendEmail
+                                : T extends AnalyticsEngine.Dataset
+                                  ? AnalyticsEngineDataset
+                                  : T extends ArtifactsNs.Namespace
+                                    ? Artifacts
+                                    : T extends RateLimitBinding
+                                      ? RateLimit
+                                      : T extends ImagesNs.ImagesBinding
+                                        ? ImagesBinding
+                                        : T extends BrowserBinding
+                                          ? BrowserRun
+                                          : T extends HyperdriveNs.Connection
+                                            ? Hyperdrive
+                                            : T extends VersionMetadataBinding
+                                              ? WorkerVersionMetadata
+                                              : T extends WorkerLoaderResource
+                                                ? WorkerLoader
+                                                : T extends WorkflowLike<
+                                                      infer Params
                                                     >
-                                                  : T extends Redacted<any>
-                                                    ? // redacteds are always stored as secret_text, so are always string
-                                                      // we JSON.stringify when not a Redacted<string>
-                                                      string
-                                                    : T;
+                                                  ? Workflow<Params>
+                                                  : T extends DurableObjectLike
+                                                    ? DurableObjectNamespace<
+                                                        Exclude<
+                                                          T["Shape"],
+                                                          undefined
+                                                        >
+                                                      >
+                                                    : T extends Redacted<any>
+                                                      ? // redacteds are always stored as secret_text, so are always string
+                                                        // we JSON.stringify when not a Redacted<string>
+                                                        string
+                                                      : T;
 
 /**
  * Cloudflare service-binding wire shape for an Effect-native Worker.