alchemy 2.0.0-beta.24 → 2.0.0-beta.26

package/src/Cloudflare/Workers/Worker.ts

@@ -22,7 +22,6 @@ import { pathToFileURL } from "node:url";
 import type * as rolldown from "rolldown";
 import Sonda from "sonda/rolldown";
 import type * as vite from "vite";
-import { AdoptPolicy } from "../../AdoptPolicy.ts";
 import { AlchemyContext } from "../../AlchemyContext.ts";
 import * as Artifacts from "../../Artifacts.ts";
 import * as Binding from "../../Binding.ts";
@@ -1105,11 +1104,42 @@ export const LiveWorkerProvider = () =>
       const reconcileDomains = (
         scriptName: string,
         desired: string[],
-        previous: Worker["Attributes"]["domains"],
+        _previous: Worker["Attributes"]["domains"],
       ) =>
         Effect.gen(function* () {
+          // Always query the live state of domains attached to *this*
+          // Worker rather than trusting `_previous` from local state.
+          // State may have been wiped, populated by another machine, or
+          // simply be out of date. Without this we PUT domains that are
+          // already registered to this same Worker and Cloudflare
+          // returns a confusing "hostname already in use" error.
+          const liveAll = yield* listDomains({
+            accountId,
+            service: scriptName,
+          }).pipe(
+            Effect.map((r) =>
+              (r.result ?? []).flatMap((d) =>
+                d.id && d.hostname && d.zoneId
+                  ? [
+                      {
+                        id: d.id,
+                        hostname: d.hostname,
+                        zoneId: d.zoneId,
+                        service: d.service ?? undefined,
+                      },
+                    ]
+                  : [],
+              ),
+            ),
+            Effect.catch(() => Effect.succeed([])),
+          );
+
           const desiredSet = new Set(desired);
-          const toRemove = previous.filter((p) => !desiredSet.has(p.hostname));
+          const liveByHostname = new Map(liveAll.map((d) => [d.hostname, d]));
+
+          // Detach what's no longer wanted. Use the live list so we
+          // don't try to delete domains we no longer track.
+          const toRemove = liveAll.filter((d) => !desiredSet.has(d.hostname));
           yield* Effect.all(
             toRemove.map((d) =>
               deleteDomain({ accountId, domainId: d.id }).pipe(
@@ -1121,85 +1151,64 @@ export const LiveWorkerProvider = () =>
 
           if (desired.length === 0) return [];
 
-          const adoptEnabled = yield* Effect.serviceOption(AdoptPolicy).pipe(
-            Effect.map(Option.getOrElse(() => false)),
-          );
-
           const zoneCache = new Map<string, string>();
 
-          /**
-           * Attach `hostname` to `scriptName`, recovering from a "hostname
-           * already in use" conflict when adoption is enabled.
-           *
-           * The Cloudflare API rejects a `PUT /workers/domains` whose
-           * hostname is already registered (even when the existing entry
-           * points at the same Worker, which is exactly what happens
-           * after a state-store wipe). The SDK surfaces this as the
-           * unmatched `UnknownCloudflareError` channel because there's
-           * no dedicated error tag for it. With adoption opted-in we
-           * list domains for the hostname; if the existing entry
-           * already targets *this* Worker we adopt it in place. We
-           * never transfer a hostname off another Worker — that would
-           * silently re-route someone else's traffic.
-           */
+          // Attach `hostname` to this Worker. Skip the PUT entirely if
+          // the hostname is already attached to *this* Worker — that's a
+          // no-op for Cloudflare and avoids the "already in use" 409.
+          // If it's attached to a *different* Worker, refuse with a
+          // clear message rather than silently re-routing traffic.
           const attachDomain = Effect.fnUntraced(function* (hostname: string) {
-            const zoneId = yield* inferZoneIdForHostname(hostname, zoneCache);
-            return yield* putDomain({
-              accountId,
-              hostname,
-              service: scriptName,
-              zoneId,
-            }).pipe(
-              Effect.map((res) => ({
-                hostname,
-                id: res.id ?? "",
-                zoneId: res.zoneId ?? zoneId,
-              })),
-              Effect.catchTag("UnknownCloudflareError", (err) =>
-                adoptEnabled && /already in use/i.test(err.message)
-                  ? adoptDomainIfSameService(hostname, zoneId, err)
-                  : Effect.fail(err),
-              ),
-            );
-          });
+            const live = liveByHostname.get(hostname);
+            if (live) {
+              return {
+                hostname: live.hostname,
+                id: live.id,
+                zoneId: live.zoneId,
+              };
+            }
 
-          const adoptDomainIfSameService = Effect.fnUntraced(function* (
-            hostname: string,
-            zoneId: string,
-            originalError: { message: string },
-          ) {
-            const existing = yield* listDomains({
+            // Not attached to this Worker — but it could still belong
+            // to another Worker. Check before we try to PUT so we can
+            // emit a helpful error instead of the raw 409.
+            const otherOwner = yield* listDomains({
               accountId,
               hostname,
             }).pipe(
               Effect.map((r) =>
-                (r.result ?? []).find((d) => d.hostname === hostname),
+                (r.result ?? []).find(
+                  (d) => d.hostname === hostname && d.service !== scriptName,
+                ),
               ),
+              Effect.catch(() => Effect.succeed(undefined)),
             );
-            if (existing?.id && existing.service === scriptName) {
-              return {
-                hostname,
-                id: existing.id,
-                zoneId: existing.zoneId ?? zoneId,
-              };
+            if (otherOwner?.id) {
+              return yield* Effect.die(
+                new Error(
+                  `Cannot attach hostname '${hostname}' to Worker '${scriptName}': ` +
+                    `it is already attached to Worker '${otherOwner.service ?? "<unknown>"}'. ` +
+                    `Detach it from that Worker first, or pick a different hostname.`,
+                ),
+              );
             }
-            // The hostname exists but on a different Worker. Refuse to
-            // hijack it; surface a more actionable message than the raw
-            // Cloudflare error.
-            return yield* Effect.die(
-              new Error(
-                `Cannot attach hostname '${hostname}' to Worker '${scriptName}': ` +
-                  `it is already attached to Worker '${existing?.service ?? "<unknown>"}'. ` +
-                  `Detach it from that Worker first, or pick a different hostname. ` +
-                  `(Cloudflare reported: ${originalError.message})`,
-              ),
-            );
+
+            const zoneId = yield* inferZoneIdForHostname(hostname, zoneCache);
+            const res = yield* putDomain({
+              accountId,
+              hostname,
+              service: scriptName,
+              zoneId,
+            });
+            return {
+              hostname,
+              id: res.id ?? "",
+              zoneId: res.zoneId ?? zoneId,
+            };
           });
 
-          const applied = yield* Effect.all(
-            desired.map(attachDomain),
-            { concurrency: "unbounded" },
-          );
+          const applied = yield* Effect.all(desired.map(attachDomain), {
+            concurrency: "unbounded",
+          });
           return applied;
         });
 
@@ -1288,21 +1297,15 @@ export const LiveWorkerProvider = () =>
           return undefined;
         }
 
-        // Handle AssetsWithHash (from Build resource)
-        // Props are resolved by Plan, so Input<string> values are already strings at runtime
         if (
           typeof assets === "object" &&
           "path" in assets &&
           "hash" in assets
         ) {
-          const result = yield* readAssets({
+          return yield* readAssets({
             directory: assets.path as string,
             config: assets.config,
           });
-          return {
-            ...result,
-            hash: assets.hash as string,
-          };
         }
 
         // Handle string path or AssetsProps
@@ -1630,31 +1633,25 @@ ${[
         let metadataAssets:
           | workers.PutScriptRequest["metadata"]["assets"]
           | undefined;
-        let keepAssets = false;
+        const keepAssets = false;
         if (assets) {
-          if (output?.hash?.assets !== assets.hash) {
-            yield* Effect.logInfo(
-              `Cloudflare Worker ${olds ? "update" : "create"}: uploading assets for ${name}`,
-            );
-            const { jwt } = yield* uploadAssets(
-              accountId,
-              name,
-              assets,
-              session,
-            );
-            metadataAssets = {
-              jwt,
-              config: assets.config,
-            };
-          } else {
-            yield* Effect.logInfo(
-              `Cloudflare Worker update: reusing existing assets for ${name}`,
-            );
-            metadataAssets = {
-              config: assets.config,
-            };
-            keepAssets = true;
-          }
+          // Always upload assets on every deploy. The "skip if hash
+          // unchanged" optimization was the source of subtle bundle/
+          // asset desync bugs (deploy succeeds but worker serves 404s
+          // because the bundle references hashed asset filenames that
+          // aren't in the still-on-Cloudflare manifest). The upload
+          // session is content-addressed on Cloudflare's side — only
+          // genuinely-new asset bytes are PUT; unchanged assets cost
+          // a manifest check and nothing else, so the optimization
+          // wasn't worth the failure mode.
+          yield* Effect.logInfo(
+            `Cloudflare Worker ${olds ? "update" : "create"}: uploading assets for ${name}`,
+          );
+          const { jwt } = yield* uploadAssets(accountId, name, assets, session);
+          metadataAssets = {
+            jwt,
+            config: assets.config,
+          };
           metadataBindings.push({
             type: "assets",
             name: "ASSETS",
@@ -1951,11 +1948,19 @@ ${[
           const input = yield* hashDirectory(props.vite);
           return input !== output.hash?.input;
         }
+        // Always recompute both hashes by walking `dist/` (assets) and
+        // re-bundling the worker. The previous short-circuit
+        // (`Effect.succeed(output.hash.assets)`) compared the cached
+        // hash to itself and could never detect drift, and the
+        // `props.assets.hash` form is the *input* (source) hash which
+        // misses non-deterministic build output (e.g. Astro/Vite
+        // shuffling content-hashed filenames between builds). The
+        // result of either shortcut was deploying a new bundle on top
+        // of stale assets and 404'ing in production. Re-walking is the
+        // only correct comparison.
         const [assetsHash, bundleHash] = yield* Effect.all(
           [
-            "assets" in output && output.hash?.assets
-              ? Effect.succeed(output.hash.assets)
-              : prepareAssets(props.assets).pipe(Effect.map((a) => a?.hash)),
+            prepareAssets(props.assets).pipe(Effect.map((a) => a?.hash)),
             prepareBundle(id, props).pipe(Effect.map((b) => b.hash)),
           ],
           { concurrency: "unbounded" },

package/src/Output.ts

@@ -499,7 +499,9 @@ export const upstreamAny = (
 ): {
   [ID in string]: Resource;
 } => {
-  if (isExpr(value)) {
+  if (isResource(value)) {
+    return { [value.FQN]: value as Resource };
+  } else if (isExpr(value)) {
     return upstream(value);
   } else if (Array.isArray(value)) {
     return Object.assign({}, ...value.map(resolveUpstream));
@@ -517,7 +519,11 @@ export const upstreamAny = (
 
 // TODO(sam): add a type
 export const upstream = <E extends Output<any, any>>(expr: E): any => {
-  if (isResourceExpr(expr)) {
+  if (isResource(expr)) {
+    return {
+      [(expr as unknown as Resource).FQN]: expr,
+    };
+  } else if (isResourceExpr(expr)) {
     return {
       [expr.src.FQN]: expr.src,
     };
@@ -541,6 +547,8 @@ export const upstream = <E extends Output<any, any>>(expr: E): any => {
 export const resolveUpstream = <const A>(value: A): any => {
   if (isPrimitive(value)) {
     return {} as any;
+  } else if (isResource(value)) {
+    return { [(value as unknown as Resource).FQN]: value } as any;
   } else if (isOutput(value)) {
     return upstream(value) as any;
   } else if (Array.isArray(value)) {

package/src/Stack.ts

@@ -184,7 +184,7 @@ export const make =
                 `    providers: Cloudflare.providers(),\n` +
                 `    state: Cloudflare.state(), // <-- required\n` +
                 `  }, ...)\n` +
-                `See https://alchemy.run/concepts/state-store for available state stores.`,
+                `See https://v2.alchemy.run/concepts/state-store for available state stores.`,
             ),
           );
         }
@@ -249,7 +249,7 @@ export const CurrentStack = Effect.serviceOption(Stack)
 const platform = Layer.mergeAll(
   PlatformServices,
   FetchHttpClient.layer,
-  Logger.layer([fileLogger("out")]),
+  Logger.layer([fileLogger("out")], { mergeWithExisting: true }),
 );
 // override alchemy state store, CLI/reporting, state, and Config
 const alchemy = Layer.mergeAll(

package/src/Telemetry/Layer.ts

@@ -1,6 +1,7 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as OtlpLogger from "effect/unstable/observability/OtlpLogger";
 import * as OtlpMetrics from "effect/unstable/observability/OtlpMetrics";
 import * as OtlpSerialization from "effect/unstable/observability/OtlpSerialization";
 import * as OtlpTracer from "effect/unstable/observability/OtlpTracer";
@@ -11,6 +12,7 @@ import { collectAttributes, isTelemetryDisabled } from "./Attributes.ts";
 
 const TRACES_URL = "https://otel.alchemy.run/v1/traces";
 const METRICS_URL = "https://otel.alchemy.run/v1/metrics";
+const LOGS_URL = "https://otel.alchemy.run/v1/logs";
 
 const SERVICE_NAME = "alchemy-cli";
 
@@ -35,8 +37,18 @@ const buildOtlpLayer = (
     resource,
     exportInterval: "1 second",
   });
+  // Replace (don't merge with) the default stdout logger here; downstream
+  // commands re-add their own `fileLogger`/`consolePretty` via
+  // `Logger.layer([...], { mergeWithExisting: true })`, which stacks on top
+  // of this OtlpLogger without resurrecting Effect's default stdout logger.
+  const logger = OtlpLogger.layer({
+    url: LOGS_URL,
+    resource,
+    exportInterval: "1 second",
+    mergeWithExisting: false,
+  });
 
-  return Layer.mergeAll(tracer, metrics).pipe(
+  return Layer.mergeAll(tracer, metrics, logger).pipe(
     Layer.provide(OtlpSerialization.layerJson),
     Layer.provide(FetchHttpClient.layer),
   );