alchemy 2.0.0-beta.65 → 2.0.0-beta.67

package/src/Cloudflare/Website/Vite.ts

@@ -47,28 +47,34 @@ export interface ViteProps<Bindings extends WorkerBindingProps = {}>
  * ```
  *
  * @section SSR Frameworks
- * For SSR frameworks like TanStack Start or SolidStart, enable
- * `nodejs_compat` so the server bundle can use Node.js APIs.
+ * SSR frameworks like TanStack Start or SolidStart work with a single
+ * call — the `nodejs_compat` compatibility flag is enabled by default
+ * so the server bundle can use Node.js APIs.
  *
  * @example TanStack Start
  * ```typescript
- * const app = yield* Cloudflare.Website.Vite("TanStackStart", {
- *   compatibility: {
- *     flags: ["nodejs_compat"],
- *   },
- * });
+ * const app = yield* Cloudflare.Website.Vite("TanStackStart");
  * ```
  *
  * @example SolidStart with worker-first routing
  * ```typescript
  * const app = yield* Cloudflare.Website.Vite("SolidStart", {
- *   compatibility: {
- *     flags: ["nodejs_compat"],
- *   },
  *   assets: { runWorkerFirst: true },
  * });
  * ```
  *
+ * @example React Router
+ * React Router's server build (`virtual:react-router/server-build`) is a
+ * build manifest with no default export, so it cannot be deployed as the
+ * Worker entry directly. Point `main` at a module that wraps it with
+ * `createRequestHandler` (React Router's Cloudflare template ships this
+ * as `workers/app.ts`):
+ * ```typescript
+ * const app = yield* Cloudflare.Website.Vite("ReactRouter", {
+ *   main: "workers/app.ts",
+ * });
+ * ```
+ *
  * @section React Server Components
  * Frameworks that emit more than one server environment (e.g. React
  * Server Components, which split into an `rsc` environment and an `ssr`
@@ -80,9 +86,6 @@ export interface ViteProps<Bindings extends WorkerBindingProps = {}>
  * @example React Router with RSC
  * ```typescript
  * const app = yield* Cloudflare.Website.Vite("ReactRouterRSC", {
- *   compatibility: {
- *     flags: ["nodejs_compat"],
- *   },
  *   viteEnvironments: {
  *     entry: "rsc",
  *     children: ["ssr"],
@@ -116,9 +119,6 @@ export interface ViteProps<Bindings extends WorkerBindingProps = {}>
  * @example Vue SPA
  * ```typescript
  * const app = yield* Cloudflare.Website.Vite("Vue", {
- *   compatibility: {
- *     flags: ["nodejs_compat"],
- *   },
  *   assets: {
  *     htmlHandling: "auto-trailing-slash",
  *     notFoundHandling: "single-page-application",
@@ -140,6 +140,22 @@ export interface ViteProps<Bindings extends WorkerBindingProps = {}>
  * });
  * ```
  *
+ * @example Rebuilding when a sibling workspace package changes
+ * The default scope only hashes files under the project root (plus the
+ * nearest lockfile), so edits to a sibling workspace package the app
+ * imports do not retrigger the build on their own. Add the sibling's
+ * sources with a `../` include glob — and keep `lockfile: true`, since
+ * providing `include` otherwise drops the lockfile from the hash:
+ * ```typescript
+ * const site = yield* Cloudflare.Website.Vite("Web", {
+ *   rootDir: "apps/web",
+ *   memo: {
+ *     include: ["**\/*", "../../packages/env/src/**"],
+ *     lockfile: true,
+ *   },
+ * });
+ * ```
+ *
  * @section Class Form
  * Calling `Vite` with no arguments returns a constructor you can
  * `extend` to declare the Worker as a named class. The class is both
@@ -148,9 +164,7 @@ export interface ViteProps<Bindings extends WorkerBindingProps = {}>
  *
  * @example Declaring a Worker class
  * ```typescript
- * class Website extends Cloudflare.Website.Vite<Website>()("Website", {
- *   compatibility: { flags: ["nodejs_compat"] },
- * }) {}
+ * class Website extends Cloudflare.Website.Vite<Website>()("Website") {}
  *
  * const site = yield* Website;
  * ```

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.