alchemy 2.0.0-beta.34 → 2.0.0-beta.35

package/src/Cloudflare/Workers/Worker.ts

@@ -1,9 +1,7 @@
 import type * as cf from "@cloudflare/workers-types";
-import cloudflareRolldown from "@distilled.cloud/cloudflare-rolldown-plugin";
 import cloudflareVite from "@distilled.cloud/cloudflare-vite-plugin";
 import * as workers from "@distilled.cloud/cloudflare/workers";
 import * as zones from "@distilled.cloud/cloudflare/zones";
-import type * as Cause from "effect/Cause";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
@@ -12,39 +10,30 @@ import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
-import * as Queue from "effect/Queue";
 import * as Redacted from "effect/Redacted";
 import * as Schedule from "effect/Schedule";
 import * as Scope from "effect/Scope";
-import * as Stream from "effect/Stream";
-import * as Socket from "effect/unstable/socket/Socket";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import type * as rolldown from "rolldown";
-import Sonda from "sonda/rolldown";
 import type * as vite from "vite";
 import { Unowned } from "../../AdoptPolicy.ts";
 import { AlchemyContext } from "../../AlchemyContext.ts";
-import * as Artifacts from "../../Artifacts.ts";
 import * as Binding from "../../Binding.ts";
 import { hashDirectory, type MemoOptions } from "../../Build/Memo.ts";
 import * as Bundle from "../../Bundle/Bundle.ts";
-import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
 import type { ScopedPlanStatusSession } from "../../Cli/Cli.ts";
 import { isResolved } from "../../Diff.ts";
 import { ExecutionContext } from "../../ExecutionContext.ts";
 import type { HttpEffect } from "../../Http.ts";
 import type { InputProps } from "../../Input.ts";
 import * as Output from "../../Output.ts";
-import { createPhysicalName } from "../../PhysicalName.ts";
 import {
   Platform,
   type Main,
   type PlatformProps,
   type Rpc,
 } from "../../Platform.ts";
-import type { LogLine } from "../../Provider.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource, type ResourceBinding } from "../../Resource.ts";
 import * as Serverless from "../../Serverless/index.ts";
@@ -72,6 +61,7 @@ import {
   type AssetsConfig,
   type AssetsProps,
 } from "./Assets.ts";
+import { getCompatibility } from "./Compatibility.ts";
 import {
   isDurableObjectExport,
   isDurableObjectNamespaceLike,
@@ -81,7 +71,8 @@ import { workersHttpHandler } from "./HttpServer.ts";
 import { LocalWorkerProvider } from "./LocalWorkerProvider.ts";
 import { Request } from "./Request.ts";
 import { makeRpcStub } from "./Rpc.ts";
-import { makeEffectVirtualEntry } from "./WorkerBundle.ts";
+import { WorkerBundle } from "./WorkerBundle.ts";
+import { createWorkerName } from "./WorkerName.ts";
 
 const WorkerTypeId = "Cloudflare.Worker";
 type WorkerTypeId = typeof WorkerTypeId;
@@ -269,7 +260,16 @@ export interface WorkerProps<
   };
   limits?: WorkerLimits;
   placement?: WorkerPlacement;
-  env?: Record<string, string | Redacted.Redacted<string>>;
+  env?: Record<
+    string,
+    | string
+    | number
+    | boolean
+    | null
+    | readonly unknown[]
+    | { readonly [key: string]: unknown }
+    | Redacted.Redacted<string>
+  >;
   exports?: string[];
   bindings?: Bindings;
   /**
@@ -411,7 +411,7 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
  * ```typescript
  * export default class MyWorker extends Cloudflare.Worker<MyWorker>()(
  *   "MyWorker",
- *   { main: import.meta.path },
+ *   { main: import.meta.filename },
  *   Effect.gen(function* () {
  *     // init: bind resources
  *     const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
@@ -446,7 +446,7 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
  * // src/WorkerB.ts
  * export default class WorkerB extends Cloudflare.Worker<WorkerB>()(
  *   "WorkerB",
- *   { main: import.meta.path },
+ *   { main: import.meta.filename },
  * ) {}
  *
  * export default WorkerB.make(
@@ -473,7 +473,7 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
  *
  * export default class WorkerA extends Cloudflare.Worker<WorkerA>()(
  *   "WorkerA",
- *   { main: import.meta.path },
+ *   { main: import.meta.filename },
  *   Effect.gen(function* () {
  *     const b = yield* Cloudflare.Worker.bind(WorkerB);
  *     return {
@@ -492,7 +492,7 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
  * @example Enabling Node.js compatibility
  * ```typescript
  * {
- *   main: import.meta.path,
+ *   main: import.meta.filename,
  *   compatibility: {
  *     flags: ["nodejs_compat"],
  *     date: "2026-03-17",
@@ -503,7 +503,7 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
  * @example Serving static assets
  * ```typescript
  * {
- *   main: import.meta.path,
+ *   main: import.meta.filename,
  *   assets: "./public",
  * }
  * ```
@@ -521,7 +521,7 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
  * @example Enabling logs and traces
  * ```typescript
  * {
- *   main: import.meta.path,
+ *   main: import.meta.filename,
  *   observability: {
  *     enabled: true,
  *     headSamplingRate: 1,
@@ -1064,12 +1064,11 @@ export const LiveWorkerProvider = () =>
 
       const { accountId } = yield* CloudflareEnvironment;
       const virtualEntryPlugin = yield* Bundle.virtualEntryPlugin;
+      const bundler = yield* WorkerBundle;
       const stack = yield* Stack;
 
       const createScriptSubdomain = yield* workers.createScriptSubdomain;
-      const createScriptTail = yield* workers.createScriptTail;
       const deleteScript = yield* workers.deleteScript;
-      const deleteScriptTail = yield* workers.deleteScriptTail;
       const getScriptSubdomain = yield* workers.getScriptSubdomain;
       const getScriptSettings = yield* workers.getScriptScriptAndVersionSetting;
       const getSubdomain = yield* workers.getSubdomain;
@@ -1079,12 +1078,6 @@ export const LiveWorkerProvider = () =>
       const deleteDomain = yield* workers.deleteDomain;
       const listZones = yield* zones.listZones;
       const telemetry = yield* CloudflareLogs;
-      // TODO(sam): figure out why the later one from workerd breaks
-      const defaultCompatibilityDate = "2026-03-17";
-      // const defaultCompatibilityDate = yield* Effect.promise(() =>
-      //   // @ts-expect-error no types for workerd
-      //   import("workerd").then((m) => m.compatibilityDate as string),
-      // );
 
       const getAccountSubdomain = (accountId: string) =>
         getSubdomain({
@@ -1105,14 +1098,6 @@ export const LiveWorkerProvider = () =>
           previewsEnabled: enabled ? true : undefined,
         });
 
-      const createWorkerName = (id: string, name: string | undefined) =>
-        name
-          ? Effect.succeed(name)
-          : createPhysicalName({
-              id,
-              maxLength: 54,
-            }).pipe(Effect.map((name) => name.toLowerCase()));
-
       // Convert non-ASCII hostnames (emoji, IDN, etc.) to punycode so the
       // Cloudflare API receives the form it stores domains in. `new URL(...)`
       // does IDNA via WHATWG URL parsing — `📦.alchemy.run` → `xn--5z8h.alchemy.run`.
@@ -1262,12 +1247,24 @@ export const LiveWorkerProvider = () =>
             }
 
             const zoneId = yield* inferZoneIdForHostname(hostname, zoneCache);
+            // Same eventual-consistency window as `setWorkerSubdomain`:
+            // PUT /accounts/.../workers/domains right after `putScript`
+            // can return `WorkerNotFound` until Cloudflare's script
+            // registry has propagated. Retry on that specific tag.
             const res = yield* putDomain({
               accountId,
               hostname,
               service: scriptName,
               zoneId,
-            });
+            }).pipe(
+              Effect.retry({
+                while: (error: { _tag?: string }) =>
+                  error?._tag === "WorkerNotFound",
+                schedule: Schedule.exponential(200).pipe(
+                  Schedule.both(Schedule.recurs(15)),
+                ),
+              }),
+            );
             return {
               hostname,
               id: res.id ?? "",
@@ -1383,67 +1380,27 @@ export const LiveWorkerProvider = () =>
         );
       });
 
-      const getCompatibility = (props: WorkerProps) => ({
-        compatibilityDate:
-          props.compatibility?.date ?? defaultCompatibilityDate,
-        compatibilityFlags: props.compatibility?.flags
-          ? [
-              ...props.compatibility.flags,
-              ...(props.isExternal ? [] : ["nodejs_compat"]),
-            ].filter((value, index, self) => self.indexOf(value) === index)
-          : props.isExternal
-            ? []
-            : ["nodejs_compat"],
-      });
-
       const prepareBundle = (id: string, props: WorkerProps) =>
-        Effect.gen(function* () {
-          const main = yield* fs.realPath(props.main);
-          const cwd = yield* findCwdForBundle(main);
-          const { compatibilityDate, compatibilityFlags } =
-            getCompatibility(props);
-          const buildBundle = (plugins?: rolldown.RolldownPluginOption) =>
-            Bundle.build(
-              {
-                input: main,
-                cwd,
-                plugins: [
-                  cloudflareRolldown({ compatibilityDate, compatibilityFlags }),
-                  plugins,
-                  ...(props.build?.metafile ? [Sonda({ open: false })] : []),
-                ],
-                checks: {
-                  // Suppress unresolved import warnings for unrelated AWS packages
-                  unresolvedImport: false,
-                },
-              },
-              {
-                format: "esm",
-                sourcemap: "hidden",
-                minify: true,
-                keepNames: true,
-                dir: `.alchemy/bundles/${id}`,
+        bundler.build({
+          id,
+          main: props.main,
+          compatibility: getCompatibility(props),
+          entry: props.isExternal
+            ? {
+                kind: "external",
+              }
+            : {
+                kind: "effect",
+                exports: (props.exports ?? {}) as any,
               },
-              { pure: props.build?.pure },
-            );
-
-          if (props.isExternal) {
-            const bundle = yield* buildBundle();
-            return bundle;
-          }
-
-          const script = makeEffectVirtualEntry((props.exports ?? {}) as any, {
-            name: stack.name,
-            stage: stack.stage,
-          });
-          return yield* buildBundle(virtualEntryPlugin(script));
-        }).pipe(Artifacts.cached("build"));
+          stack: { name: stack.name, stage: stack.stage },
+          userOptions: props.build,
+        });
 
       const viteBuild = Effect.fnUntraced(function* (props: WorkerProps) {
         let assetsDirectory: string | undefined;
         let serverBundle: vite.Rolldown.OutputBundle | undefined;
-        const { compatibilityDate, compatibilityFlags } =
-          getCompatibility(props);
+        const compatibility = getCompatibility(props);
 
         yield* Effect.promise(async () => {
           const vite = await loadVite(props.vite?.rootDir);
@@ -1462,13 +1419,10 @@ export const LiveWorkerProvider = () =>
                   },
                 },
               },
-              builder: {
-                sharedConfigBuild: true,
-              },
               plugins: [
                 cloudflareVite({
-                  compatibilityDate,
-                  compatibilityFlags,
+                  compatibilityDate: compatibility.date,
+                  compatibilityFlags: compatibility.flags,
                 }),
                 {
                   name: "output:ssr",
@@ -1698,18 +1652,24 @@ export const LiveWorkerProvider = () =>
         // Add environment variables as metadata bindings
         if (news.env) {
           for (const [key, value] of Object.entries(news.env)) {
-            if (value == null) continue;
+            if (value === undefined) continue;
             if (Redacted.isRedacted(value)) {
               metadataBindings.push({
                 type: "secret_text",
                 name: key,
                 text: Redacted.value(value),
               });
-            } else {
+            } else if (typeof value === "string") {
               metadataBindings.push({
                 type: "plain_text",
                 name: key,
-                text: typeof value === "string" ? value : String(value),
+                text: value,
+              });
+            } else {
+              metadataBindings.push({
+                type: "json",
+                name: key,
+                json: value,
               });
             }
           }
@@ -1862,11 +1822,13 @@ export const LiveWorkerProvider = () =>
           }),
         );
 
-        const metadata = {
+        const compatibility = getCompatibility(news);
+        const metadata: workers.PutScriptRequest["metadata"] = {
           assets: metadataAssets,
           bindings: metadataBindings,
           bodyPart: undefined,
-          ...getCompatibility(news),
+          compatibilityDate: compatibility.date,
+          compatibilityFlags: compatibility.flags,
           containers:
             metadataContainers.length > 0 ? metadataContainers : undefined,
           keepAssets,
@@ -1949,7 +1911,21 @@ export const LiveWorkerProvider = () =>
           yield* session.note(
             `${desiredSubdomainEnabled ? "Enabling" : "Disabling"} workers.dev subdomain...`,
           );
-          yield* setWorkerSubdomain(name, desiredSubdomainEnabled);
+          // Cloudflare's script registry is eventually consistent — for the
+          // first few hundred ms after `putScript` returns, POST /subdomain
+          // can still get back `WorkerNotFound` (a generic "unknown error"
+          // body). Bigger uploads race harder. Retry the subdomain toggle on
+          // that specific tag with a short exponential backoff; same pattern
+          // we use elsewhere in this provider for DO-namespace propagation.
+          yield* setWorkerSubdomain(name, desiredSubdomainEnabled).pipe(
+            Effect.retry({
+              while: (error: { _tag?: string }) =>
+                error?._tag === "WorkerNotFound",
+              schedule: Schedule.exponential(200).pipe(
+                Schedule.both(Schedule.recurs(15)),
+              ),
+            }),
+          );
         }
         const desiredDomains = normalizeDomains(news.domain);
         const previousDomains = output?.domains ?? [];
@@ -2328,80 +2304,11 @@ export const LiveWorkerProvider = () =>
             scriptName: output.workerName,
           }).pipe(Effect.catchTag("WorkerNotFound", () => Effect.void));
         }),
-        tail: ({ output }) => {
-          const runTailSession = Effect.gen(function* () {
-            const { id: tailId, url } = yield* createScriptTail({
-              scriptName: output.workerName,
-              accountId: output.accountId,
-              body: { filters: [] },
-            });
-
-            const socket = yield* Socket.makeWebSocket(url, {
-              protocols: ["trace-v1"],
-            });
-
-            const queue = yield* Queue.make<LogLine, Cause.Done>();
-
-            yield* socket
-              .runRaw((raw) => {
-                const text =
-                  typeof raw === "string" ? raw : new TextDecoder().decode(raw);
-                const data: TailEventMessage = JSON.parse(text);
-                const eventTs = new Date(data.eventTimestamp ?? Date.now());
-
-                if (data.event && "request" in data.event) {
-                  const reqEvent = data.event;
-                  const pathname = (() => {
-                    try {
-                      return new URL(reqEvent.request.url).pathname;
-                    } catch {
-                      return reqEvent.request.url;
-                    }
-                  })();
-                  const status = reqEvent.response?.status ?? 500;
-                  Queue.offerUnsafe(queue, {
-                    timestamp: eventTs,
-                    message: `${reqEvent.request.method} ${pathname} > ${status} (cpu: ${Math.round(data.cpuTime)}ms, wall: ${Math.round(data.wallTime)}ms)`,
-                  });
-                }
-
-                for (const log of data.logs) {
-                  const msg = log.message.join(" ");
-                  Queue.offerUnsafe(queue, {
-                    timestamp: new Date(log.timestamp),
-                    message: log.level === "log" ? msg : `${log.level}: ${msg}`,
-                  });
-                }
-
-                for (const exception of data.exceptions) {
-                  Queue.offerUnsafe(queue, {
-                    timestamp: new Date(exception.timestamp),
-                    message: `${exception.name} ${exception.message}\n${exception.stack}`,
-                  });
-                }
-              })
-              .pipe(
-                Effect.ensuring(
-                  Effect.all([
-                    deleteScriptTail({
-                      scriptName: output.workerName,
-                      id: tailId,
-                      accountId: output.accountId,
-                    }).pipe(Effect.ignore),
-                    Queue.end(queue),
-                  ]),
-                ),
-                Effect.ignore,
-                Effect.forkChild(),
-              );
-
-            return Stream.fromQueue(queue);
-          });
-
-          return Stream.unwrap(runTailSession).pipe(
-            Stream.repeat(Schedule.spaced("1 second")),
-          );
-        },
+        tail: ({ output }) =>
+          telemetry.tailScript({
+            accountId: output.accountId,
+            scriptName: output.workerName,
+          }),
         logs: ({ output, options }) =>
           telemetry.queryLogs({
             accountId: output.accountId,
@@ -2419,33 +2326,6 @@ export const LiveWorkerProvider = () =>
     }),
   );
 
-interface TailEventMessage {
-  eventTimestamp?: number;
-  wallTime: number;
-  cpuTime: number;
-  truncated: boolean;
-  outcome: string;
-  scriptName: string;
-  exceptions: {
-    name: string;
-    message: string;
-    stack: string;
-    timestamp: string;
-  }[];
-  logs: {
-    message: string[];
-    level: string;
-    timestamp: string;
-  }[];
-  event:
-    | {
-        request: { method: string; url: string };
-        response?: { status: number };
-      }
-    | null
-    | undefined;
-}
-
 const contentTypeFromExtension = (extension: string) => {
   switch (extension) {
     case ".wasm":

package/src/Cloudflare/Workers/WorkerBundle.ts

@@ -4,7 +4,9 @@ import * as FileSystem from "effect/FileSystem";
 import { flow } from "effect/Function";
 import type * as Path from "effect/Path";
 import * as Stream from "effect/Stream";
+import { fileURLToPath } from "node:url";
 import type * as rolldown from "rolldown";
+import Sonda from "sonda/rolldown";
 import * as Artifacts from "../../Artifacts.ts";
 import * as Bundle from "../../Bundle/Bundle.ts";
 import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
@@ -13,6 +15,7 @@ import {
   isDurableObjectExport,
   type DurableObjectExport,
 } from "./DurableObjectNamespace.ts";
+import type { WorkerProps } from "./Worker.ts";
 import { isWorkflowExport, type WorkflowExport } from "./Workflow.ts";
 
 export interface WorkerBundleOptions {
@@ -31,6 +34,7 @@ export interface WorkerBundleOptions {
         exports: Record<string, DurableObjectExport | WorkflowExport>;
       };
   stack: { name: string; stage: string };
+  userOptions: WorkerProps["build"] | undefined;
 }
 
 export const WorkerBundle = Effect.gen(function* () {
@@ -41,15 +45,7 @@ export const WorkerBundle = Effect.gen(function* () {
   const makeOptions = Effect.fnUntraced(function* (
     options: WorkerBundleOptions,
   ) {
-    const realMain = yield* fs.realPath(options.main).pipe(
-      Effect.mapError(
-        (cause) =>
-          new Bundle.BundleError({
-            message: `Failed to find real path for bundle: ${options.main}`,
-            cause,
-          }),
-      ),
-    );
+    const realMain = yield* sanitizeMain(options.main);
     const inputOptions: rolldown.InputOptions = {
       input: realMain,
       cwd: yield* findCwdForBundle(realMain).pipe(
@@ -72,6 +68,7 @@ export const WorkerBundle = Effect.gen(function* () {
               makeEffectVirtualEntry(options.entry.exports, options.stack),
             )
           : undefined,
+        ...(options.userOptions?.metafile ? [Sonda({ open: false })] : []),
       ],
       checks: {
         // Suppress unresolved import warnings for unrelated AWS packages
@@ -85,14 +82,39 @@ export const WorkerBundle = Effect.gen(function* () {
       keepNames: true,
       dir: `.alchemy/bundles/${options.id}`,
     };
-    return { inputOptions, outputOptions };
+    const extraOptions: Bundle.BundleExtraOptions = {
+      pure: options.userOptions?.pure,
+    };
+    return { inputOptions, outputOptions, extraOptions };
   });
 
+  const sanitizeMain = (main: string) =>
+    Effect.sync(() => {
+      try {
+        return fileURLToPath(main);
+      } catch {
+        return main;
+      }
+    }).pipe(
+      Effect.flatMap((path) => fs.realPath(path)),
+      Effect.mapError(
+        (cause) =>
+          new Bundle.BundleError({
+            message: `Failed to find real path for bundle: ${main}`,
+            cause,
+          }),
+      ),
+    );
+
   return {
     build: flow(
       makeOptions,
       Effect.flatMap((resolved) =>
-        Bundle.build(resolved.inputOptions, resolved.outputOptions),
+        Bundle.build(
+          resolved.inputOptions,
+          resolved.outputOptions,
+          resolved.extraOptions,
+        ),
       ),
       Artifacts.cached("build"),
     ),
@@ -100,7 +122,11 @@ export const WorkerBundle = Effect.gen(function* () {
       makeOptions,
       Stream.fromEffect,
       Stream.flatMap((resolved) =>
-        Bundle.watch(resolved.inputOptions, resolved.outputOptions),
+        Bundle.watch(
+          resolved.inputOptions,
+          resolved.outputOptions,
+          resolved.extraOptions,
+        ),
       ),
     ),
   };

package/src/Cloudflare/Zone.ts

@@ -0,0 +1,88 @@
+import {
+  Credentials,
+  formatHeaders,
+} from "@distilled.cloud/cloudflare/Credentials";
+import * as Effect from "effect/Effect";
+
+export type ZoneReference = string | { zoneId: string; name?: string };
+
+export const isZoneId = (zone: string): boolean => /^[a-f0-9]{32}$/i.test(zone);
+
+export const matchesZoneHostname = (
+  zoneName: string,
+  hostname: string,
+): boolean => hostname === zoneName || hostname.endsWith(`.${zoneName}`);
+
+export const resolveZoneId = ({
+  accountId,
+  zone,
+  hostname,
+}: {
+  accountId: string;
+  zone: ZoneReference | undefined;
+  hostname: string;
+}) =>
+  Effect.gen(function* () {
+    if (typeof zone === "object") return zone.zoneId;
+    if (typeof zone === "string" && isZoneId(zone)) return zone;
+
+    const lookup = zone ?? hostname;
+    for (const candidate of zoneNameCandidates(lookup)) {
+      const match = yield* findZoneByName({ accountId, name: candidate });
+      if (match) return match.id;
+    }
+    return yield* Effect.fail(
+      new Error(`Cloudflare zone not found for ${lookup}`),
+    );
+  });
+
+type ZoneListResponse = {
+  success: boolean;
+  errors?: { message?: string }[];
+  result?: { id: string; name: string; account: { id?: string | null } }[];
+};
+
+const findZoneByName = ({
+  accountId,
+  name,
+}: {
+  accountId: string;
+  name: string;
+}) =>
+  Effect.gen(function* () {
+    const credentialsEffect = yield* Credentials;
+    const credentials = yield* credentialsEffect;
+    const url = new URL(`${credentials.apiBaseUrl}/zones`);
+    url.searchParams.set("account.id", accountId);
+    url.searchParams.set("name", name);
+    url.searchParams.set("per_page", "1");
+
+    const json = yield* Effect.tryPromise({
+      try: async () => {
+        const response = await fetch(url, {
+          headers: formatHeaders(credentials),
+        });
+        return (await response.json()) as ZoneListResponse;
+      },
+      catch: (cause) => new Error(`Failed to list Cloudflare zones`, { cause }),
+    });
+
+    if (!json.success) {
+      return yield* Effect.fail(
+        new Error(
+          json.errors?.map((error) => error.message).join(", ") ??
+            `Failed to list Cloudflare zones`,
+        ),
+      );
+    }
+
+    return json.result?.find(
+      (candidate) =>
+        candidate.name === name && candidate.account.id === accountId,
+    );
+  });
+
+const zoneNameCandidates = (hostname: string): string[] => {
+  const parts = hostname.split(".");
+  return parts.slice(0, -1).map((_, index) => parts.slice(index).join("."));
+};