alchemy 2.0.0-beta.82 → 2.0.0-beta.83

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -50,6 +50,10 @@ import { sha256 } from "../../Util/sha256.ts";
 import { ANSI_RESET, ansiFg, colorsEnabled } from "../../Util/Terminal.ts";
 import { theme } from "../../Util/Theme.ts";
 import type { DevContainerImage } from "../Containers/ContainerApplication.ts";
+import {
+  assertBindingContainersOnAsyncClasses,
+  mergeWorkerContainers,
+} from "../Containers/ContainerConfiguration.ts";
 import { localAccountId } from "../LocalAccount.ts";
 import {
   isLiveId,
@@ -61,6 +65,7 @@ import type { ConsumerSettings } from "../Queues/Consumer.ts";
 import type { WorkerAssetsConfig, WorkerProps } from "../Workers/Worker.ts";
 import { readAssetsConfigFiles } from "./Assets.ts";
 import { getCompatibility } from "./Compatibility.ts";
+import { isDurableObjectExport } from "./DurableObject.ts";
 import { LocalEdge } from "./LocalEdge.ts";
 import { routePatternHost } from "./RoutePattern.ts";
 import { materializeRuntimeBindings, WorkerValidationError } from "./RuntimeBindings.ts";
@@ -361,6 +366,7 @@ export const LocalWorkerProvider = () =>
         // change (a Dockerfile edit, a rebuilt bundle) would never change
         // the config and the running container would serve stale code.
         const containerHashes: Record<string, string> = {};
+        const containerRows: NonNullable<Worker["Binding"]["containers"]> = [];
         const boundEnv: Record<string, any> = { ...props.env };
         for (const { data } of bindings) {
           if (data.env) Object.assign(boundEnv, data.env);
@@ -415,28 +421,33 @@ export const LocalWorkerProvider = () =>
               };
             }
           }
-          if (data.containers) {
-            const toRuntimeImage = (image: DevContainerImage) => ({
-              ...image,
-              env: unwrapRedacted(image.env),
-            });
-            for (const container of data.containers) {
-              if (container.devImages !== undefined) {
-                // Durable Object-managed: named images, selected at start().
-                const images: Record<string, RuntimeContainerImage> = {};
-                for (const [name, image] of Object.entries(container.devImages)) {
-                  images[name] = toRuntimeImage(image);
-                }
-                containers[container.className] = { images };
-              } else if (container.dev) {
-                containers[container.className] = toRuntimeImage(container.dev);
-              } else {
-                return yield* Effect.die(`Container ${container.className} has no dev image`);
-              }
-              if (container.hash !== undefined) {
-                containerHashes[container.className] = container.hash;
-              }
+          if (data.containers) containerRows.push(...data.containers);
+        }
+        // A Durable Object-managed class merges the images of every bound
+        // Container (keyed by Container id); a fleet class has one image.
+        const toRuntimeImage = (image: DevContainerImage) => ({
+          ...image,
+          env: unwrapRedacted(image.env),
+        });
+        const exportMap = (props.exports ?? {}) as Record<string, unknown>;
+        yield* assertBindingContainersOnAsyncClasses(
+          containerRows,
+          Object.keys(exportMap).filter((name) => isDurableObjectExport(exportMap[name])),
+        );
+        for (const container of yield* mergeWorkerContainers(containerRows)) {
+          if (container.devImages !== undefined) {
+            const images: Record<string, RuntimeContainerImage> = {};
+            for (const [key, image] of Object.entries(container.devImages)) {
+              images[key] = toRuntimeImage(image);
             }
+            containers[container.className] = { images };
+          } else if (container.dev) {
+            containers[container.className] = toRuntimeImage(container.dev);
+          } else {
+            return yield* Effect.die(`Container ${container.className} has no dev image`);
+          }
+          if (container.hash !== undefined) {
+            containerHashes[container.className] = container.hash;
           }
         }
         for (const [className, dev] of Object.entries(containers)) {

package/src/Cloudflare/Workers/Worker.ts

@@ -1318,6 +1318,8 @@ export type Worker<Bindings = any> = Resource<
     observability?: Pick<WorkerObservability, "traces">;
     containers?: {
       className: string;
+      /** Set when an async `Cloudflare.DurableObject(name, { containers })` binding contributed the row. */
+      attachedBy?: "binding";
       /** Application name and prepared images for the native container API. */
       name?: string;
       images?: Record<string, string>;

package/src/Cloudflare/Workers/WorkerAsyncBindings.ts

@@ -19,7 +19,14 @@ import { isDataset } from "../AnalyticsEngine/Dataset.ts";
 import { isNamespace } from "../Artifacts/Namespace.ts";
 import type { Container } from "../Containers/Container.ts";
 import type { ContainerApplication } from "../Containers/ContainerApplication.ts";
-import { workerContainerBinding } from "../Containers/ContainerConfiguration.ts";
+import {
+  containerApplicationSettings,
+  DurableObjectContainerBindingError,
+  durableObjectContainerBinding,
+  isDurableObjectContainerResource,
+  workerContainerBinding,
+} from "../Containers/ContainerConfiguration.ts";
+import { declareDurableObjectApplication } from "../Containers/DurableObjectApplication.ts";
 import { isDatabase } from "../D1/Database.ts";
 import { isSendEmail } from "../Email/SendEmail.ts";
 import { isApp } from "../Flagship/App.ts";
@@ -48,7 +55,11 @@ import { isAI } from "./AI.ts";
 import { isAssets } from "./Assets.ts";
 import { isBinding as isWorkerOnlyBinding } from "./Binding.ts";
 import { isBrowser } from "./Browser.ts";
-import { isDurableObjectLike, normalizeTransferredFrom } from "./DurableObject.ts";
+import {
+  type DurableObjectLike,
+  isDurableObjectLike,
+  normalizeTransferredFrom,
+} from "./DurableObject.ts";
 import { isRateLimit } from "./RateLimit.ts";
 import { isSecretKey } from "./SecretKey.ts";
 import { isVersionMetadata } from "./VersionMetadata.ts";
@@ -264,8 +275,16 @@ export const bindWorkerAsyncBindings = Effect.fn(function* (
           } satisfies WorkflowBinding;
         }
 
+        // Durable Object-managed Containers attached to a hosted class. Both
+        // halves describe this env entry, so they share its `sid`.
+        const containers =
+          isDurableObjectLike(binding) && binding.containers?.length
+            ? yield* bindDurableObjectContainers(resource, bindingName, binding)
+            : undefined;
+
         yield* resource.bind`${bindingName}`({
           bindings: [resolvedBindingMeta],
+          containers,
           hyperdrives: isHyperdriveConnection(binding)
             ? yield* getHyperdriveDevOriginForHost(binding, resource)
             : undefined,
@@ -317,8 +336,11 @@ const isContainerApplicationResource = (value: unknown): value is ContainerAppli
   (value as { Type?: unknown }).Type === "Cloudflare.Container";
 
 /**
- * Wire a Container bound directly on an async Worker's `env`
- * (`env: { Sandbox: Cloudflare.Container("Sandbox", { image }) }`). Mirrors
+ * Wire a fleet Container bound directly on an async Worker's `env`
+ * (`env: { Sandbox: Cloudflare.Container("Sandbox", { image }) }`). A
+ * Durable Object-managed Container fails with
+ * {@link DurableObjectContainerBindingError}: it attaches through
+ * `Cloudflare.DurableObject(className, { containers })` instead. Mirrors
  * v1 alchemy, where a Container binding is a Durable Object namespace plus
  * its ContainerApplication in one declaration:
  *
@@ -358,6 +380,14 @@ const bindContainerClass = Effect.fn(function* (
       `Worker binding '${bindingName}' is a Container without a deployable image. Declare the container with props (image, or context/dockerfile) to bind it on an async Worker — effectful (main) containers require an Effect-native Durable Object host.`,
     );
   }
+  if (isDurableObjectContainerResource(application)) {
+    return yield* Effect.die(
+      new DurableObjectContainerBindingError({
+        bindingName,
+        message: `Worker binding '${bindingName}' is a Durable Object-managed Container ('${application.LogicalId}'). Attach it to the Durable Object class that starts it: env: { ${bindingName}: Cloudflare.DurableObject("${className}", { containers: [${application.LogicalId}] }) }.`,
+      }),
+    );
+  }
   // Both halves of the Worker's side describe the same env entry, so they
   // share one `sid`. Binding rows are collapsed by sid (last write wins), so
   // splitting them across two `bind` calls silently drops the namespace
@@ -384,6 +414,67 @@ const bindContainerClass = Effect.fn(function* (
   });
 });
 
+/**
+ * Binding mistakes die with a {@link DurableObjectContainerBindingError}: the
+ * Worker declaration hook cannot fail, and these are programmer errors.
+ *
+ * Attach the Durable Object-managed Containers of
+ * `Cloudflare.DurableObject(className, { containers })` to the class: each
+ * adds its image to the class's one container application (declared once per
+ * class, deduped by id) and returns the Worker's `containers` row for it. The
+ * same machinery as an Effect-native Durable Object's `yield* Container`.
+ */
+const bindDurableObjectContainers = Effect.fn(function* (
+  resource: Worker,
+  bindingName: string,
+  binding: DurableObjectLike,
+) {
+  const className = binding.className ?? binding.name;
+  if (binding.scriptName !== undefined) {
+    return yield* Effect.die(
+      new DurableObjectContainerBindingError({
+        bindingName,
+        message: `Worker binding '${bindingName}' attaches containers to Durable Object class '${className}' hosted by another Worker. Attach containers where the class is hosted.`,
+      }),
+    );
+  }
+  const classApplication = yield* declareDurableObjectApplication(resource, className);
+  const namespaceId = resource.durableObjectNamespaces.pipe(
+    Output.map((namespaces) => namespaces?.[className]),
+  );
+  const rows = [];
+  for (const decl of binding.containers ?? []) {
+    const declaration = (decl as { Application?: unknown }).Application;
+    const application =
+      isYieldableEffectLike(declaration) && !Output.isOutput(declaration)
+        ? yield* declaration as Effect.Effect<unknown>
+        : undefined;
+    if (
+      !isContainerApplicationResource(application) ||
+      !isDurableObjectContainerResource(application)
+    ) {
+      return yield* Effect.die(
+        new DurableObjectContainerBindingError({
+          bindingName,
+          message: `Cloudflare.DurableObject("${className}", { containers }) lists a Container that is not Durable Object-managed. Declare it with schedulingPolicy: "durable_object" and an image source (image, or context/dockerfile).`,
+        }),
+      );
+    }
+    yield* classApplication.bind`${application.LogicalId}`({
+      durableObjects: { namespaceId },
+      container: {
+        id: application.LogicalId,
+        settings: containerApplicationSettings(application),
+      },
+    });
+    rows.push({
+      ...durableObjectContainerBinding(className, classApplication, application),
+      attachedBy: "binding" as const,
+    });
+  }
+  return rows;
+});
+
 type BindingSpec = InputProps<WorkerBinding>;
 
 /**

package/src/Cloudflare/Workers/WorkerProvider.ts

@@ -28,6 +28,10 @@ import { cachedFunction } from "../../Util/cached-function.ts";
 import { initialCwd } from "../../Util/Node.ts";
 import { sha256Object } from "../../Util/sha256.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import {
+  assertBindingContainersOnAsyncClasses,
+  mergeWorkerContainers,
+} from "../Containers/ContainerConfiguration.ts";
 import { localRuntimeServices } from "../LocalRuntime.ts";
 import { CloudflareLogs } from "../Logs.ts";
 import { detachQueueConsumersOfScript } from "../Queues/Consumer.ts";
@@ -3449,9 +3453,16 @@ export const LiveWorkerProvider = () =>
         // Compute delete-class candidates. Candidates are validated against
         // observed namespace ownership below — a class may already have been
         // transferred to another script by its new host's deploy.
+        // Several bindings may name one class (e.g. two Containers sharing a
+        // Durable Object class): a class stays while any binding hosts it.
+        const currentDoClasses = new Set(currentDoBindings.map((binding) => binding.className));
         const deletedClassCandidates: string[] = [];
         for (const [logicalId, className] of Object.entries(oldDoClassNameByLogicalId)) {
-          if (!currentDoClassNameByLogicalId[logicalId]) {
+          if (
+            !currentDoClassNameByLogicalId[logicalId] &&
+            !currentDoClasses.has(className) &&
+            !deletedClassCandidates.includes(className)
+          ) {
             deletedClassCandidates.push(className);
           }
         }
@@ -3469,7 +3480,9 @@ export const LiveWorkerProvider = () =>
               "className" in oldBinding &&
               oldBinding.className &&
               ownedLocally &&
-              !currentDoBindings.some((binding) => binding.bindingName === oldBinding.name)
+              !currentDoBindings.some((binding) => binding.bindingName === oldBinding.name) &&
+              !currentDoClasses.has(oldBinding.className) &&
+              !deletedClassCandidates.includes(oldBinding.className)
             ) {
               deletedClassCandidates.push(oldBinding.className);
             }
@@ -3607,15 +3620,31 @@ export const LiveWorkerProvider = () =>
         }
 
         // Collect container-backed classes so we can send container metadata.
-        // `name` and `images` are only set for Durable Object-managed applications.
-        const containerClasses = new Map(
-          bindings.flatMap((b) =>
-            (b.data.containers ?? []).map(
-              ({ className, name, images }) => [className, { className, name, images }] as const,
-            ),
-          ),
+        // A Durable Object-managed class merges the images of every bound
+        // Container under one entry; `name` and `images` are only set for it.
+        const containerRows = bindings.flatMap((b) => b.data.containers ?? []);
+        yield* assertBindingContainersOnAsyncClasses(
+          containerRows,
+          effectNativeDurableObjectClasses(news.exports),
+        );
+        const containerClasses = (yield* mergeWorkerContainers(containerRows)).map(
+          ({ className, name, images }) => ({ className, name, images }),
         );
 
+        // Classes the deployed script hosts locally, by migration tag or by
+        // an observed local Durable Object binding.
+        const deployedDoClasses = new Set([
+          ...Object.values(oldDoClassNameByLogicalId),
+          ...oldBindings.flatMap((old) =>
+            old.type === "durable_object_namespace" &&
+            "className" in old &&
+            old.className &&
+            (!("scriptName" in old) || old.scriptName === undefined || old.scriptName === name)
+              ? [old.className]
+              : [],
+          ),
+        ]);
+
         // Compute new, renamed, and transferred classes
         const newClasses: string[] = [];
         const newSqliteClasses: string[] = [];
@@ -3653,6 +3682,24 @@ export const LiveWorkerProvider = () =>
               previousClassName = observed.className;
             }
           }
+          // Another binding already hosts this class on the deployed script
+          // (several bindings may name one class): the class exists, so a
+          // binding added for it creates nothing.
+          if (
+            (!previousClassName || previousClassName !== binding.className) &&
+            deployedDoClasses.has(binding.className)
+          ) {
+            continue;
+          }
+          // A logical id that moved to another class while its old class is
+          // still hosted by another binding is a new class, not a rename.
+          if (
+            previousClassName !== undefined &&
+            previousClassName !== binding.className &&
+            currentDoClasses.has(previousClassName)
+          ) {
+            previousClassName = undefined;
+          }
           if (!previousClassName) {
             // A class new to this script is a host move when the declaration
             // says so: `transferredFrom` lists the former host(s) — moves
@@ -3685,9 +3732,17 @@ export const LiveWorkerProvider = () =>
             }
             // Default all new Durable Object classes to SQLite. Cloudflare
             // recommends SQLite for new namespaces, and container-backed
-            // Durable Objects require it.
-            newSqliteClasses.push(binding.className);
-          } else if (previousClassName !== binding.className) {
+            // Durable Objects require it. Several bindings may name one class
+            // (e.g. two Containers sharing a class); create it once.
+            if (!newSqliteClasses.includes(binding.className)) {
+              newSqliteClasses.push(binding.className);
+            }
+          } else if (
+            previousClassName !== binding.className &&
+            !renamedClasses.some(
+              (rename) => rename.from === previousClassName && rename.to === binding.className,
+            )
+          ) {
             renamedClasses.push({ from: previousClassName, to: binding.className });
           }
         }
@@ -3732,7 +3787,7 @@ export const LiveWorkerProvider = () =>
         );
         const transferringIn = new Set(transferredClasses.map((transfer) => transfer.to));
 
-        const metadataContainers = [...containerClasses.values()];
+        const metadataContainers = containerClasses;
 
         const compatibility = getCompatibility(news);
         const tailConsumers = resolveTailConsumers(news.tailConsumers);
@@ -4791,6 +4846,10 @@ export const LiveWorkerProvider = () =>
           // Container binding (mirrors reconcile's `containerClasses`).
           // Mapping every DO class to a container would wrongly mark plain DOs
           // as container-backed in the placeholder.
+          yield* assertBindingContainersOnAsyncClasses(
+            bindings.flatMap((b) => b.data.containers ?? []),
+            exportDerived.map((binding) => binding.className),
+          );
           const containers = Array.from(
             new Set(bindings.flatMap((b) => (b.data.containers ?? []).map((c) => c.className))),
           ).map((className) => ({ className }));
@@ -5776,6 +5835,12 @@ ${worker}${doClasses.map((className) => `export class ${className} extends Alche
  * binding-derived entry wins on a collision so the `alchemy:dos:` tag keys off
  * the same logical id (the binding sid) that `reconcile` writes.
  */
+/** The Durable Object classes a Worker implements as Effect-native exports. */
+function effectNativeDurableObjectClasses(exports: WorkerProps["exports"] | undefined) {
+  const exportMap = (exports ?? {}) as Record<string, unknown>;
+  return Object.keys(exportMap).filter((name) => isDurableObjectExport(exportMap[name]));
+}
+
 function mergeDurableObjectClasses(
   exportDerived: ReadonlyArray<{
     logicalId: string;