alchemy 2.0.0-beta.77 → 2.0.0-beta.78

package/src/Cloudflare/Containers/ContainerApplication.ts

@@ -8,7 +8,7 @@ import {
   type PlatformServices,
 } from "../../Platform.ts";
 import { Resource } from "../../Resource.ts";
-import * as Server from "../../Server/index.ts";
+import type { ProcessServices } from "../../Server/Process.ts";
 import type { Providers } from "../Providers.ts";
 import type { InlineDockerfile } from "../../Docker/Dockerfile.ts";
 import { ContainerTypeId } from "./Container.ts";
@@ -108,7 +108,8 @@ export interface ContainerApplicationPropsBase extends PlatformProps {
   /**
    * Instance type for each deployment. Defaults to wrangler's `"lite"` tier
    * (1/16 vCPU, 256 MiB, 2 GB disk) when no explicit {@link vcpu}/{@link memory}/
-   * {@link disk} is set. (`"dev"` is wrangler's deprecated alias for `"lite"`.)
+   * {@link memoryMib}/{@link disk} is set. (`"dev"` is wrangler's deprecated
+   * alias for `"lite"`.)
    * @default "lite"
    */
   instanceType?: ContainerApplication.InstanceType;
@@ -132,6 +133,12 @@ export interface ContainerApplicationPropsBase extends PlatformProps {
    * Memory allocation override for each deployment.
    */
   memory?: string;
+  /**
+   * Memory allocation override for each deployment, in MiB.
+   * Custom sizing requires at least 1 {@link vcpu} and 3072 MiB of memory
+   * per vCPU for the first 4 vCPUs.
+   */
+  memoryMib?: number;
   /**
    * Disk allocation override for each deployment.
    */
@@ -344,7 +351,7 @@ export interface AnyContainerApplicationProps extends ContainerApplicationPropsB
 export type ContainerServices =
   | ContainerApplication
   | PlatformServices
-  | Server.ProcessServices;
+  | ProcessServices;
 
 export type ContainerShape = Main<ContainerServices>;
 

package/src/Cloudflare/Containers/ContainerPlatform.ts

@@ -8,7 +8,7 @@ import {
   packEnvValueKeepRedacted,
   unpackEnvValue,
 } from "../../RuntimeContext.ts";
-import * as Server from "../../Server/index.ts";
+import type { ProcessContext } from "../../Server/Process.ts";
 import type { Fetcher } from "../Fetcher.ts";
 import { fromCloudflareFetcher, toCloudflareFetcher } from "../Fetcher.ts";
 import { DurableObject } from "../Workers/DurableObject.ts";
@@ -53,12 +53,12 @@ export const ContainerPlatform: Platform<
   ContainerApplication,
   ContainerServices,
   ContainerShape,
-  Server.ProcessContext,
+  ProcessContext,
   Container
 > = Platform(
   "Cloudflare.Container",
   {
-    createRuntimeContext: (id: string): Server.ProcessContext => {
+    createRuntimeContext: (id: string): ProcessContext => {
       const runners: Effect.Effect<void, never, any>[] = [];
       const env: Record<string, any> = {};
 
@@ -111,12 +111,12 @@ export const ContainerPlatform: Platform<
           }),
         get: <T>(key: string) =>
           // Read straight from `process.env` — see `unpackEnvValue` for why
-          // this must never resolve through `Config.string`.
+          // this must never resolve through `Config.String`.
           Effect.sync(() => unpackEnvValue<T>(process.env[key]) as T),
         run: ((effect: Effect.Effect<void, never, any>) =>
           Effect.sync(() => {
             runners.push(effect);
-          })) as unknown as Server.ProcessContext["run"],
+          })) as unknown as ProcessContext["run"],
         serve,
         exports: Effect.sync(() => ({
           default: Effect.all(
@@ -136,7 +136,7 @@ export const ContainerPlatform: Platform<
             },
           ),
         })),
-      } as Server.ProcessContext;
+      } as ProcessContext;
     },
   },
   {

package/src/Cloudflare/Containers/ContainerProvider.ts

@@ -1,5 +1,6 @@
 import * as Containers from "@distilled.cloud/cloudflare/containers";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as Redacted from "effect/Redacted";
@@ -37,6 +38,7 @@ import {
   validateContainerImageProps,
 } from "./ContainerBundle.ts";
 import { ContainerPlatform } from "./ContainerPlatform.ts";
+import { retryContainerPublication } from "./ContainerPublication.ts";
 
 /**
  * The image source resolved from a {@link ContainerApplicationProps}. Selects
@@ -191,6 +193,7 @@ export const LiveContainerProvider = () =>
             props.instanceType ??
             (props.vcpu === undefined &&
             props.memory === undefined &&
+            props.memoryMib === undefined &&
             props.disk === undefined
               ? "lite"
               : undefined),
@@ -199,6 +202,7 @@ export const LiveContainerProvider = () =>
           secrets: props.secrets,
           vcpu: props.vcpu,
           memory: props.memory,
+          memoryMib: props.memoryMib,
           disk: props.disk,
           environmentVariables: Object.entries(env).map(([name, value]) => ({
             name,
@@ -320,7 +324,7 @@ export const LiveContainerProvider = () =>
             ),
             HttpClientRequest.setHeader(
               "Accept",
-              "application/vnd.oci.image.manifest.v1+json, application/vnd.docker.distribution.manifest.v2+json",
+              "application/vnd.oci.image.index.v1+json, application/vnd.oci.image.manifest.v1+json, application/vnd.docker.distribution.manifest.list.v2+json, application/vnd.docker.distribution.manifest.v2+json",
             ),
           );
           const response = yield* http.execute(request).pipe(
@@ -519,15 +523,15 @@ export const LiveContainerProvider = () =>
         };
       });
 
-      const buildAndPushImage = Effect.fn("buildAndPushImage")(function* (
+      const publicationPlatform = "linux/amd64";
+      const publishImage = Effect.fn("publishImage")(function* (
         id: string,
         props: AnyContainerApplicationProps,
         build: ImageBuild,
         imageRef: string,
-        previousImageRef: string | undefined,
         session?: { note: (message: string) => Effect.Effect<void> },
       ) {
-        const platform = "linux/amd64";
+        const platform = publicationPlatform;
 
         if (build.kind === "prepushed") {
           // The reference already lives in the target registry — nothing to
@@ -535,17 +539,11 @@ export const LiveContainerProvider = () =>
           yield* Effect.logInfo(
             `Cloudflare Container image: using pre-pushed ${imageRef}`,
           );
-          const published = yield* resolvePublishedImageRef(props, imageRef);
-          return {
-            ...published,
-            previousDigest:
-              previousImageRef === undefined
-                ? undefined
-                : (yield* resolvePublishedImageRef(props, previousImageRef))
-                    .digest,
-          };
+          return yield* resolvePublishedImageRef(props, imageRef);
         }
 
+        const credentials = yield* registryCredentials(props, ["pull", "push"]);
+
         if (build.kind === "remote") {
           // Pull the pre-built image and re-tag it to the Cloudflare registry
           // reference; nothing is built locally.
@@ -557,6 +555,17 @@ export const LiveContainerProvider = () =>
           }
           yield* docker.image.pull(build.image, platform);
           yield* docker.image.tag(build.image, imageRef);
+          yield* Effect.logInfo(
+            `Cloudflare Container image: pushing ${imageRef}`,
+          );
+          if (session) {
+            yield* session.note(`Pushing container image ${imageRef}...`);
+          }
+          // Push the same platform that was pulled. A containerd image store
+          // may also hold a host-architecture variant under this tag.
+          yield* docker.image
+            .push(imageRef, credentials, platform)
+            .pipe(retryContainerPublication);
         } else if (build.kind === "external") {
           // Build the user's Dockerfile directly against their context dir so
           // relative `COPY`/`ADD` paths resolve as the author intended.
@@ -566,12 +575,18 @@ export const LiveContainerProvider = () =>
           if (session) {
             yield* session.note(`Building container image ${imageRef}...`);
           }
-          yield* docker.image.build({
-            tag: imageRef,
-            context: build.context,
-            platform,
-            file: build.dockerfile,
-          });
+          yield* docker.image
+            .build(
+              {
+                tag: imageRef,
+                context: build.context,
+                platform,
+                file: build.dockerfile,
+              },
+              undefined,
+              credentials,
+            )
+            .pipe(retryContainerPublication);
         } else {
           // Effect-native program: materialize the generated Dockerfile and
           // bundled chunks into a stable staging dir, then build.
@@ -601,57 +616,19 @@ export const LiveContainerProvider = () =>
               content: f.content,
             })),
           });
-          yield* docker.image.build({
-            tag: imageRef,
-            context: contextDir,
-            platform,
-          });
-        }
-
-        yield* Effect.logInfo(
-          `Cloudflare Container image: pushing ${imageRef}`,
-        );
-        if (session) {
-          yield* session.note(`Pushing container image ${imageRef}...`);
+          yield* docker.image
+            .build(
+              {
+                tag: imageRef,
+                context: contextDir,
+                platform,
+              },
+              undefined,
+              credentials,
+            )
+            .pipe(retryContainerPublication);
         }
 
-        const credentials = yield* registryCredentials(props, ["pull", "push"]);
-
-        // Cloudflare's container registry intermittently answers blob HEAD
-        // probes with 500 under concurrent suite push load. Ride that out
-        // with a bounded retry rather than failing the whole deploy.
-        //
-        // Push the SAME platform we pulled/built. With Docker's containerd
-        // image store a tag can hold several platform variants (e.g. a stray
-        // host-arch `docker pull` adds arm64 next to our amd64), and an
-        // un-scoped push then ships the wrong variant — Cloudflare's amd64
-        // hosts never boot it and the app 503s "provisioning" forever.
-        yield* docker.image
-          .push(
-            imageRef,
-            {
-              username: credentials.username,
-              password: credentials.password,
-              server: credentials.server,
-            },
-            platform,
-          )
-          .pipe(
-            Effect.retry({
-              while: (e) => {
-                const msg = String(e).toLowerCase();
-                return (
-                  msg.includes("500") ||
-                  msg.includes("internal server error") ||
-                  msg.includes("unexpected status")
-                );
-              },
-              schedule: Schedule.max([
-                Schedule.spaced("3 seconds"),
-                Schedule.recurs(5),
-              ]),
-            }),
-          );
         // Resolve the pushed manifest digest from the registry itself rather
         // than scraping `docker push` output: one mechanism for every image
         // source (local build, remote re-push, pre-pushed tag), and the
@@ -660,10 +637,66 @@ export const LiveContainerProvider = () =>
         return {
           imageRef: `${repositoryFromImageRef(imageRef)}@${digest}`,
           digest,
+        };
+      });
+
+      // Applications with identical image inputs can share one immutable
+      // registry reference. Keep publication state within this provider instance.
+      const publications = new Map<string, ReturnType<typeof publishImage>>();
+      const buildAndPushImage = Effect.fn("buildAndPushImage")(function* (
+        id: string,
+        props: AnyContainerApplicationProps,
+        build: ImageBuild,
+        imageRef: string,
+        imageHash: string,
+        previousImageRef: string | undefined,
+        session?: { note: (message: string) => Effect.Effect<void> },
+      ) {
+        const { accountId } = yield* yield* CloudflareEnvironment;
+        const key = JSON.stringify([
+          accountId,
+          props.registryId ?? "registry.cloudflare.com",
+          publicationPlatform,
+          build.kind,
+          imageHash,
+          // The source hash follows gitignore, not Docker's context rules.
+          build.kind === "external" && !isInlineDockerfile(props.dockerfile)
+            ? [build.context, build.dockerfile]
+            : undefined,
+        ]);
+        const candidate: ReturnType<typeof publishImage> = yield* Effect.cached(
+          publishImage(id, props, build, imageRef, session).pipe(
+            Effect.onExit((exit) =>
+              Exit.isFailure(exit)
+                ? Effect.sync(() => {
+                    // A failed or interrupted publisher must not poison a
+                    // later attempt, or remove an entry that replaced it.
+                    if (publications.get(key) === candidate) {
+                      publications.delete(key);
+                    }
+                  })
+                : Effect.void,
+            ),
+          ),
+        );
+        const publication = yield* Effect.sync(() => {
+          // Allocate atomically: concurrent callers execute only the winning
+          // candidate, sharing both its in-flight work and successful result.
+          const existing = publications.get(key);
+          if (existing) return existing;
+          publications.set(key, candidate);
+          return candidate;
+        });
+        const published = yield* publication;
+        return {
+          ...published,
+          // Previous image identity belongs to each application, not the
+          // shared image publication. Resolve it separately for every caller.
           previousDigest:
             previousImageRef === undefined
               ? undefined
-              : yield* resolveRegistryDigest(previousImageRef, credentials),
+              : (yield* resolvePublishedImageRef(props, previousImageRef))
+                  .digest,
         };
       });
 
@@ -883,6 +916,7 @@ export const LiveContainerProvider = () =>
             news,
             build,
             imageRef,
+            imageHash,
             existing.hash?.digest === undefined
               ? existing.configuration.image
               : undefined,
@@ -992,8 +1026,10 @@ export const LiveContainerProvider = () =>
       const getDurableObjects = (
         bindings: ResourceBinding<ContainerApplication["Binding"]>[],
       ) => {
+        // A stale Worker namespace map can resolve a binding to an object
+        // without an id. It does not request removing the live attachment.
         const dos = bindings.flatMap((b) =>
-          b.data.durableObjects ? [b.data.durableObjects] : [],
+          b.data.durableObjects?.namespaceId ? [b.data.durableObjects] : [],
         );
         // A single DO namespace may appear in multiple bindings (e.g. when
         // a Container is referenced by several resources). Dedupe by namespaceId.
@@ -1046,9 +1082,17 @@ export const LiveContainerProvider = () =>
 
           const hasDurableObjects =
             (yield* getDurableObjects(newBindings)) !== undefined;
+          const hasUnresolvedAttachment =
+            !hasDurableObjects &&
+            newBindings.some(
+              (binding) => binding.data.durableObjects !== undefined,
+            );
           const hadDurableObjects =
             (yield* getDurableObjects(oldBindings)) !== undefined;
-          if (hasDurableObjects !== hadDurableObjects) {
+          if (
+            !hasUnresolvedAttachment &&
+            hasDurableObjects !== hadDurableObjects
+          ) {
             return { action: "replace" } as const;
           }
 
@@ -1064,6 +1108,23 @@ export const LiveContainerProvider = () =>
             return { action: "update", stables: ["accountId"] } as const;
           }
 
+          const application = yield* Containers.getContainerApplication({
+            accountId: output.accountId,
+            applicationId: output.applicationId,
+          }).pipe(
+            Effect.catchTag("ContainerApplicationNotFound", () =>
+              Effect.succeed(undefined),
+            ),
+          );
+          if (
+            application &&
+            (application.id !== output.applicationId ||
+              application.name !== output.applicationName ||
+              application.accountId !== output.accountId)
+          ) {
+            return { action: "replace" } as const;
+          }
+
           const { imageHash, dev } = yield* computeImage(
             id,
             news,
@@ -1091,6 +1152,7 @@ export const LiveContainerProvider = () =>
             news,
             build,
             imageRef,
+            imageHash,
             undefined,
             session,
           );
@@ -1151,13 +1213,13 @@ export const LiveContainerProvider = () =>
             `Cloudflare Container reconcile: starting ${name}`,
           );
           const durableObjects = yield* getDurableObjects(bindings);
+          const hasUnresolvedAttachment =
+            durableObjects === undefined &&
+            bindings.some(
+              (binding) => binding.data.durableObjects !== undefined,
+            );
           const { accountId } = yield* yield* CloudflareEnvironment;
           const env = makeContainerEnv(news, accountId, bindings);
-          const { build, imageRef, imageHash, dev } = yield* computeImage(
-            id,
-            news,
-            env,
-          );
 
           // Observe — re-fetch the cached application to confirm it still
           // exists. Cloudflare reports a deleted container application as
@@ -1192,12 +1254,45 @@ export const LiveContainerProvider = () =>
             }
           }
 
+          // Only use cached attachment data after confirming the application
+          // is missing. An observed live attachment outranks stale state.
+          const recordedDurableObjects = existing
+            ? existing.durableObjects
+            : output?.accountId === accountId && isLiveId(output.applicationId)
+              ? output.durableObjects
+              : undefined;
+          const durableObjectsForRecovery =
+            durableObjects ??
+            (hasUnresolvedAttachment && recordedDurableObjects?.namespaceId
+              ? recordedDurableObjects
+              : undefined);
+          if (
+            hasUnresolvedAttachment &&
+            durableObjectsForRecovery === undefined
+          ) {
+            return yield* Effect.fail(
+              new Error(
+                `Container application "${name}" has an unresolved Durable Object namespace and no recorded attachment. Reconcile its Worker first.`,
+              ),
+            );
+          }
+          const { build, imageRef, imageHash, dev } = yield* computeImage(
+            id,
+            news,
+            env,
+          );
+
           // Special case: precreate produced an application without the
-          // durable object attachment, but the real reconcile now has one
-          // (or vice versa). The DO attachment is immutable, so we delete
+          // durable object attachment, but the real reconcile now has one.
+          // The DO attachment is immutable, so we delete
           // and recreate. Adoption-by-namespace is preferred when an app
           // already owns the namespace.
-          if (existing && !deepEqual(existing.durableObjects, durableObjects)) {
+          // An unresolved declaration is not an intentional removal.
+          if (
+            existing &&
+            !hasUnresolvedAttachment &&
+            !deepEqual(existing.durableObjects, durableObjects)
+          ) {
             if (durableObjects) {
               const owner = yield* findApplicationByNamespace(
                 durableObjects.namespaceId,
@@ -1233,6 +1328,7 @@ export const LiveContainerProvider = () =>
                 news,
                 build,
                 imageRef,
+                imageHash,
                 existing.hash?.digest === undefined
                   ? existing.configuration.image
                   : undefined,
@@ -1306,7 +1402,9 @@ export const LiveContainerProvider = () =>
               news,
               bindings,
               existing,
-              durableObjects,
+              // Keep the live attachment through the ghost-recreate fallback
+              // when the desired value is unresolved.
+              durableObjects: durableObjectsForRecovery,
               session,
             });
           }
@@ -1320,6 +1418,7 @@ export const LiveContainerProvider = () =>
             news,
             build,
             imageRef,
+            imageHash,
             undefined,
             session,
           );
@@ -1339,7 +1438,7 @@ export const LiveContainerProvider = () =>
             bindings,
             name,
             configuration,
-            durableObjects,
+            durableObjects: durableObjectsForRecovery,
             session,
           });
           return {
@@ -1420,11 +1519,9 @@ export const LiveContainerProvider = () =>
           const name = yield* createApplicationName(id, olds?.name);
           attrs = yield* readByName(name);
           if (!attrs) return undefined;
-          // Cloudflare container applications carry no ownership signal that
-          // we can read back from the API, so a name match is not proof of
-          // ownership. Brand it `Unowned` so the engine surfaces
-          // `OwnedBySomeoneElse` unless the caller opted in via `--adopt`.
-          return Unowned(attrs);
+          // Generated names identify this instance by its random suffix.
+          // Explicit names alone do not establish ownership.
+          return olds?.name === undefined ? attrs : Unowned(attrs);
         }),
         list: () =>
           Effect.gen(function* () {

package/src/Cloudflare/Containers/ContainerPublication.ts

@@ -0,0 +1,13 @@
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import type { DockerImagePublicationError } from "../../Docker/RegistryError.ts";
+
+export const retryContainerPublication = <A, R>(
+  publication: Effect.Effect<A, DockerImagePublicationError, R>,
+) =>
+  Effect.retry(publication, {
+    while: (error) =>
+      error._tag === "DockerRegistryBlobUnknown" ||
+      error._tag === "DockerRegistryUnavailable",
+    schedule: Schedule.max([Schedule.spaced("3 seconds"), Schedule.recurs(5)]),
+  });

package/src/Cloudflare/Containers/LocalContainerProvider.ts

@@ -10,7 +10,7 @@ import * as RpcProvider from "../../Local/RpcProvider.ts";
 import { sha256Object } from "../../Util/sha256.ts";
 import { normalizeNulls } from "../../Util/stable.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
-import { generateLocalId, LOCAL_ENTRY_URL } from "../LocalRuntime.ts";
+import { generateLocalId, LOCAL_PROVIDERS_URL } from "../LocalRuntime.ts";
 import type {
   AnyContainerApplicationProps,
   ContainerApplication,
@@ -44,7 +44,7 @@ import { ContainerPlatform } from "./ContainerPlatform.ts";
 export const LocalContainerProvider = () =>
   RpcProvider.effect(
     ContainerPlatform,
-    LOCAL_ENTRY_URL,
+    LOCAL_PROVIDERS_URL,
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;
       const path = yield* Path.Path;
@@ -187,6 +187,7 @@ export const LocalContainerProvider = () =>
           secrets: props.secrets,
           vcpu: props.vcpu,
           memory: props.memory,
+          memoryMib: props.memoryMib,
           disk: props.disk,
           environmentVariables: Object.entries(env).map(([name, value]) => ({
             name,

package/src/Cloudflare/D1/Database.ts

@@ -25,7 +25,7 @@ import { recordsEqual } from "../../Util/equal.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import {
   generateLocalId,
-  LOCAL_ENTRY_URL,
+  LOCAL_PROVIDERS_URL,
   localRuntimeServices,
 } from "../LocalRuntime.ts";
 import type { Providers } from "../Providers.ts";
@@ -593,7 +593,7 @@ export const ProviderLive = () =>
 export const ProviderLocal = () =>
   RpcProvider.effect(
     Database,
-    LOCAL_ENTRY_URL,
+    LOCAL_PROVIDERS_URL,
     Effect.gen(function* () {
       // The local runtime services (workerd `Runtime`, binding plugins) and
       // the HTTP client are resolved once at layer build and closed over —
@@ -706,7 +706,7 @@ export const DatabaseProvider = () =>
     // The local provider's reconcile boots an ephemeral workerd gateway to
     // apply migrations, so it needs the shared local runtime layer. Under
     // `alchemy dev` the provider is an RPC stub (this gated layer is empty
-    // and unused) and the sidecar entry (`../Local.ts`) supplies the real
+    // and unused) and the provider group (`../Local.ts`) supplies the real
     // runtime; without the proxy the provider builds in-process and this
     // layer is real.
     local: () => ProviderLocal().pipe(Layer.provide(localRuntimeServices())),