alchemy 2.0.0-beta.75 → 2.0.0-beta.77

package/src/Cloudflare/Workers/RpcWorker.ts

@@ -14,6 +14,7 @@ import type * as RpcClientError from "effect/unstable/rpc/RpcClientError";
 import type { Dependencies } from "../../Dependencies.ts";
 import type { HttpEffect } from "../../Http.ts";
 import type { InputProps } from "../../Input.ts";
+import type { Named } from "../../Named.ts";
 import type { Rpc as RpcShape } from "../../Rpc.ts";
 import { effectClass, taggedFunction } from "../../Util/effect.ts";
 import type { Worker, WorkerProps } from "./Worker.ts";
@@ -53,17 +54,25 @@ const SchemaSymbol = Symbol.for("alchemy.RpcWorker.schema");
 // `Deps` mirrors `Cloudflare.Worker<Self, Bindings, Deps>` — declares
 // the DOs / Workers this script publishes for cross-script binding so
 // `Counter.from(WorkerA)` type-checks from another script.
+//
+// `Id` is the const logical id (`Named<Id>`), matching `Cloudflare.Worker`.
 export interface RpcWorkerYieldable<
   Self,
   Rpcs extends Rpc.Any,
   Deps = never,
-> extends Effect.Effect<
-  Worker<{}> & RpcShape<Self> & Dependencies<Deps>,
-  never,
-  any
-> {
+  Id extends string = string,
+>
+  extends
+    Effect.Effect<Worker<{}> & RpcShape<Self> & Dependencies<Deps>, never, any>,
+    Named<Id> {
   /** @internal */
   readonly [SchemaSymbol]: RpcGroup.RpcGroup<Rpcs>;
+  /**
+   * Logical id of the Worker this class declares. Copied from the
+   * underlying `Cloudflare.Worker` so callers can read it off the
+   * class without yielding (e.g. `transferredFrom: TaskWorker`).
+   */
+  readonly LogicalId: Id;
 }
 
 /**
@@ -98,11 +107,11 @@ export interface RpcWorkerClass extends Effect.Effect<
      * `Layer.Layer<Self>` so consumers that don't host the worker can
      * import the class without pulling its runtime into their bundle.
      */
-    <Rpcs extends Rpc.Any>(
-      id: string,
+    <const Id extends string, Rpcs extends Rpc.Any>(
+      id: Id,
       props: RpcWorkerProps<Rpcs>,
-    ): RpcWorkerYieldable<Self, Rpcs, Deps> & {
-      new (_: never): {};
+    ): RpcWorkerYieldable<Self, Rpcs, Deps, Id> & {
+      new (_: never): Named<Id>;
       make<InnerR = never, InitReq = never>(
         props: InputProps<WorkerProps>,
         impl: Effect.Effect<
@@ -113,20 +122,26 @@ export interface RpcWorkerClass extends Effect.Effect<
       ): Layer.Layer<Self, never, Exclude<InitReq | InnerR, never>>;
     };
     /** Inline-impl form. */
-    <Rpcs extends Rpc.Any, InnerR = never, InitReq = never>(
-      id: string,
+    <
+      const Id extends string,
+      Rpcs extends Rpc.Any,
+      InnerR = never,
+      InitReq = never,
+    >(
+      id: Id,
       props: RpcWorkerProps<Rpcs> & InputProps<WorkerProps>,
       impl: Effect.Effect<
         Effect.Effect<HttpEffect<InnerR>, never, InnerR>,
         ConfigError,
         InitReq
       >,
-    ): RpcWorkerYieldable<Self, Rpcs, Deps> & {
+    ): RpcWorkerYieldable<Self, Rpcs, Deps, Id> & {
       // Phantom — `class X extends RpcWorker<X>()(...)` carries `X`
       // through the result type via `Rpc<Self>` on the binding side;
-      // the instance shape itself is empty (no methods exposed on
-      // `new X(...)` — everything goes through `fetch`).
-      new (_: never): {};
+      // the instance shape itself is empty besides `Named<Id>` (no
+      // methods exposed on `new X(...)` — everything goes through
+      // `fetch`).
+      new (_: never): Named<Id>;
     };
   };
 
@@ -514,6 +529,17 @@ const wrapImpl = (impl: Effect.Effect<Effect.Effect<HttpEffect<any>>>) =>
     (fetch) => ({ fetch }) as unknown as { fetch: HttpEffect<any> },
   );
 
+// `effectClass` does not copy statics from the underlying Worker.
+const stampLogicalId = (
+  klass: Record<symbol | string, unknown>,
+  source: { LogicalId?: unknown },
+  id: string,
+) => {
+  klass.LogicalId =
+    typeof source.LogicalId === "string" ? source.LogicalId : id;
+  return klass;
+};
+
 const buildModular = (id: string, props: RpcWorkerProps<any>) => {
   const { schema } = props;
   // Delegate to `Cloudflare.Worker<Self>()(id, props)` (modular form)
@@ -531,7 +557,7 @@ const buildModular = (id: string, props: RpcWorkerProps<any>) => {
     ): Layer.Layer<any, never, any> => Underlying.make(props, wrapImpl(impl));
   } as unknown as Record<symbol | string, unknown>;
   klass[SchemaSymbol] = schema;
-  return klass;
+  return stampLogicalId(klass, Underlying, id);
 };
 
 const build = (
@@ -560,7 +586,7 @@ const build = (
   // still works.) `underlying` is already an Effect, so pass it directly.
   const klass = effectClass(
     underlying as Effect.Effect<Worker>,
-  ) as unknown as Record<symbol, unknown>;
+  ) as unknown as Record<symbol | string, unknown>;
   klass[SchemaSymbol] = schema;
-  return klass;
+  return stampLogicalId(klass, underlying, id);
 };

package/src/Cloudflare/Workers/Source.ts

@@ -21,6 +21,7 @@ import type * as Bundle from "../../Bundle/Bundle.ts";
 import type { WorkflowExport } from "../Workflows/Workflow.ts";
 import type { AssetReadResult, ValidationError } from "./Assets.ts";
 import type { DurableObjectExport } from "./DurableObject.ts";
+import { getToolingCompatibility } from "./Compatibility.ts";
 import { makeInlineScriptSource } from "./Sources/InlineScript.ts";
 import { makePrebuiltSource } from "./Sources/Prebuilt.ts";
 import { isPythonMain, makePythonSource } from "./Sources/Python.ts";
@@ -78,6 +79,8 @@ export interface SourceBuildOutput {
 export interface SourceContext {
   /** Logical id of the Worker resource. */
   readonly id: string;
+  /** Namespace-qualified id (`ns/Worker`) — the display prefix for log lines. */
+  readonly fqn: string;
   /** Physical script name. */
   readonly workerName: string;
   readonly compatibility: {
@@ -385,14 +388,19 @@ export const resolveSource = (
  */
 export const makeSourceContext = (params: {
   id: string;
+  fqn: string;
   workerName: string;
   props: WorkerProps;
   compatibility: { date: string; flags: string[] };
   stack: { name: string; stage: string };
 }): SourceContext => ({
   id: params.id,
+  fqn: params.fqn,
   workerName: params.workerName,
-  compatibility: params.compatibility,
+  compatibility: getToolingCompatibility(
+    params.compatibility,
+    params.props.main,
+  ),
   entry: params.props.isExternal
     ? { kind: "external" }
     : { kind: "effect", exports: params.props.exports ?? {} },

package/src/Cloudflare/Workers/Sources/Python.ts

@@ -88,6 +88,8 @@ const MANAGED_SDK_PACKAGE = "workers-runtime-sdk";
 
 export interface PythonWorkerBundleOptions {
   id: string;
+  /** Namespace-qualified id — the display prefix for log lines. */
+  fqn: string;
   /** Path (or `file://` URL) to the Worker's `.py` entry module. */
   main: string;
   compatibility: {
@@ -138,15 +140,18 @@ const runUv = Effect.fn(function* (
  * - If the Worker's directory already contains `python_modules/` (the
  *   user vendored it themselves, e.g. with `pywrangler sync` or any other
  *   tool that produces Wrangler's vendored layout), it is used as-is.
- * - Otherwise, if `pyproject.toml` exists, its `[project.dependencies]`
- *   are vendored with uv into a staging directory under `.alchemy/`:
+ * - Otherwise, the managed Workers runtime SDK and any dependencies from an
+ *   optional `pyproject.toml` are vendored with uv into a staging directory
+ *   under `.alchemy/`:
  *   resolve against the Pyodide wheel index for the runtime's Python
  *   version (`uv pip compile` → `pylock.toml`), install the prebuilt
  *   wheels into an emscripten cross-venv (`uv venv` + `uv pip install
  *   --no-build`), and copy the venv's `site-packages` out. Re-vendoring
  *   is skipped while the `pyproject.toml` hash is unchanged.
- * - With neither, the Worker has no vendored dependencies (the `workers`
- *   SDK module built into the runtime is still importable).
+ *
+ * workerd no longer bundles the `workers` Python module at current
+ * compatibility dates, so even a dependency-free Worker needs the managed
+ * SDK under `python_modules/`.
  */
 const resolvePythonModulesDir = Effect.fn(function* (
   options: PythonWorkerBundleOptions & { root: string },
@@ -159,15 +164,15 @@ const resolvePythonModulesDir = Effect.fn(function* (
   }
 
   const pyproject = path.join(options.root, "pyproject.toml");
-  if (!(yield* orDefault(fs.exists(pyproject), false))) {
-    return undefined;
-  }
+  const hasPyproject = yield* orDefault(fs.exists(pyproject), false);
 
   const pythonVersion = pythonVersionForCompatibility(options.compatibility);
   const target = PYODIDE_TARGETS[pythonVersion];
-  const pyprojectContent = yield* fs
-    .readFileString(pyproject)
-    .pipe(Effect.mapError(uvError(`Failed to read "${pyproject}"`)));
+  const pyprojectContent = hasPyproject
+    ? yield* fs
+        .readFileString(pyproject)
+        .pipe(Effect.mapError(uvError(`Failed to read "${pyproject}"`)))
+    : "";
   const inputHash = yield* sha256(
     `${pythonVersion}\0${target.index}\0${pyprojectContent}`,
   );
@@ -182,7 +187,7 @@ const resolvePythonModulesDir = Effect.fn(function* (
   }
 
   yield* Effect.logDebug(
-    `[${options.id}] Vendoring Python dependencies for ${pythonVersion} (emscripten-wasm32) with uv`,
+    `[${options.fqn}] Vendoring Python dependencies for ${pythonVersion} (emscripten-wasm32) with uv`,
   );
   yield* fs
     .makeDirectory(staging, { recursive: true })
@@ -204,7 +209,7 @@ const resolvePythonModulesDir = Effect.fn(function* (
     [
       "pip",
       "compile",
-      pyproject,
+      ...(hasPyproject ? [pyproject] : []),
       extraRequirements,
       "--python",
       target.interpreter,
@@ -410,6 +415,7 @@ export const watchPythonWorkerBundle = (options: PythonWorkerBundleOptions) =>
 export const makePythonSource = (main: string): SourceProvider => {
   const pythonOptions = (ctx: SourceContext) => ({
     id: ctx.id,
+    fqn: ctx.fqn,
     main,
     compatibility: ctx.compatibility,
   });

package/src/Cloudflare/Workers/Sources/Rolldown.ts

@@ -147,7 +147,7 @@ export const WorkerBundle = Effect.gen(function* () {
       checks: {
         // Suppress unresolved import warnings for unrelated AWS packages
         unresolvedImport: false,
-        // Suppress warning caused by static import of `@effect/platform-node/NodeServices` in `WorkerBridge.ts`
+        // The shared platform boundary keeps guarded Node/Bun adapter imports.
         ineffectiveDynamicImport: false,
       },
     };

package/src/Cloudflare/Workers/Sources/Vite.ts

@@ -14,6 +14,10 @@ import {
   type ViteBuildOutput,
 } from "../../../Bundle/Vite.ts";
 import { viteSupportsPortZero } from "@alchemy.run/cloudflare-runtime/core/internal/Port";
+import {
+  makeResourceLogger,
+  makeResourceOutput,
+} from "../../../Util/ResourceOutput.ts";
 import { hashDirectory, type MemoOptions } from "../../../Command/Memo.ts";
 import { findAvailablePort, initialCwd } from "../../../Util/Node.ts";
 import { sha256Object } from "../../../Util/sha256.ts";
@@ -163,35 +167,34 @@ export const viteBuild = (
   rootDir: string = initialCwd,
   env: Record<string, unknown>,
   pluginOptions: CloudflareVitePluginOptions,
+  fqn: string,
 ) =>
-  ConsoleService.consoleWith((console) =>
-    Effect.gen(function* () {
-      const result = yield* runViteBuildChild(
-        {
-          // Anchor to the initial cwd so the resolution itself can't race a
-          // transient chdir; the child's own cwd is this resolved root.
-          rootDir: nodePath.resolve(initialCwd, rootDir),
-          // Only `VITE_`-prefixed entries participate in the build (see
-          // `getDefine`); the rest may hold non-serializable values.
-          env: Object.fromEntries(
-            Object.entries(env).filter(([key]) => key.startsWith("VITE_")),
-          ),
-          main: pluginOptions.main,
-          compatibilityDate: pluginOptions.compatibilityDate,
-          compatibilityFlags: pluginOptions.compatibilityFlags,
-          viteEnvironments: pluginOptions.viteEnvironments,
-        },
-        (channel, line) =>
-          channel === "stderr" ? console.error(line) : console.log(line),
-      );
-      return {
-        clientDirectory: result.clientDirectory,
-        base: result.base,
-        serverBundle: Effect.succeed(result.serverBundle),
-        externalWorkspaces: Effect.succeed(new Set(result.externalWorkspaces)),
-      } satisfies ViteBuildOutput;
-    }),
-  );
+  Effect.gen(function* () {
+    const logResourceOutput = makeResourceLogger(fqn);
+    const result = yield* runViteBuildChild(
+      {
+        // Anchor to the initial cwd so the resolution itself can't race a
+        // transient chdir; the child's own cwd is this resolved root.
+        rootDir: nodePath.resolve(initialCwd, rootDir),
+        // Only `VITE_`-prefixed entries participate in the build (see
+        // `getDefine`); the rest may hold non-serializable values.
+        env: Object.fromEntries(
+          Object.entries(env).filter(([key]) => key.startsWith("VITE_")),
+        ),
+        main: pluginOptions.main,
+        compatibilityDate: pluginOptions.compatibilityDate,
+        compatibilityFlags: pluginOptions.compatibilityFlags,
+        viteEnvironments: pluginOptions.viteEnvironments,
+      },
+      logResourceOutput,
+    );
+    return {
+      clientDirectory: result.clientDirectory,
+      base: result.base,
+      serverBundle: Effect.succeed(result.serverBundle),
+      externalWorkspaces: Effect.succeed(new Set(result.externalWorkspaces)),
+    } satisfies ViteBuildOutput;
+  });
 
 /**
  * The in-process build implementation. ONLY safe inside the dedicated
@@ -381,12 +384,17 @@ export const makeViteSource = (vite: ViteOptions): SourceProvider => ({
     const path = yield* Path.Path;
     const env = yield* resolveViteEnv(ctx.env ?? {});
     const { clientDirectory, serverBundle, externalWorkspaces } =
-      yield* viteBuild(vite.rootDir, env, {
-        main: vite.main,
-        compatibilityDate: ctx.compatibility.date,
-        compatibilityFlags: ctx.compatibility.flags,
-        viteEnvironments: vite.viteEnvironments,
-      });
+      yield* viteBuild(
+        vite.rootDir,
+        env,
+        {
+          main: vite.main,
+          compatibilityDate: ctx.compatibility.date,
+          compatibilityFlags: ctx.compatibility.flags,
+          viteEnvironments: vite.viteEnvironments,
+        },
+        ctx.fqn,
+      );
     const [assets, bundle, input] = yield* Effect.all(
       [
         clientDirectory

package/src/Cloudflare/Workers/Telemetry.ts

@@ -0,0 +1,170 @@
+/**
+ * Cloudflare Workers Observability tracer as a binding layer — the
+ * platform-native counterpart of `Axiom.Telemetry`.
+ */
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Namespace from "../../Namespace.ts";
+import type { ResourceBinding } from "../../Resource.ts";
+import * as AlchemyTelemetry from "../../Telemetry.ts";
+import { getCompatibility } from "./Compatibility.ts";
+import { layer as cloudflareTracerLayer } from "./CloudflareTracer.ts";
+import { Worker, type WorkerProps } from "./Worker.ts";
+
+/**
+ * Earliest compatibility date that exposes `tracing.startActiveSpan`
+ * (`cloudflare:workers`). ISO dates compare lexically.
+ */
+export const MIN_CLOUDFLARE_TRACING_DATE = "2026-07-28";
+
+/**
+ * Thrown when {@link Telemetry} is provided on a Worker whose resolved
+ * compatibility date is older than {@link MIN_CLOUDFLARE_TRACING_DATE}.
+ */
+export class CloudflareTelemetryCompatibilityError extends Data.TaggedError(
+  "CloudflareTelemetryCompatibilityError",
+)<{
+  date: string;
+  minimumDate: string;
+}> {
+  override get message() {
+    return (
+      `Cloudflare.Telemetry() requires compatibility date >= ${this.minimumDate} ` +
+      `(tracing.startActiveSpan). This Worker is pinned to ${this.date}. ` +
+      `Set compatibility: { date: "${this.minimumDate}" } (or later) on the Worker.`
+    );
+  }
+}
+
+export interface CloudflareTelemetryProps {
+  /**
+   * Enable Workers Traces on the host Worker.
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Head-based sampling rate for Workers Traces (`0`–`1`).
+   * Omitted unless set — Cloudflare's default applies.
+   */
+  headSamplingRate?: number;
+  /**
+   * Persist traces in the Cloudflare dashboard. Omitted unless set.
+   * Pass `false` to export-only (no dashboard persist).
+   */
+  persist?: boolean;
+}
+
+const tracesFromProps = (props: CloudflareTelemetryProps) => ({
+  enabled: props.enabled ?? true,
+  ...(props.headSamplingRate !== undefined
+    ? { headSamplingRate: props.headSamplingRate }
+    : {}),
+  ...(props.persist !== undefined ? { persist: props.persist } : {}),
+});
+
+/**
+ * Fail deploy when `Cloudflare.Telemetry()` is bound and the Worker's
+ * resolved compatibility date is too old for `tracing.startActiveSpan`.
+ *
+ * @internal
+ */
+export const assertCloudflareTelemetryCompatibility = (
+  news: WorkerProps,
+  bindings: ReadonlyArray<ResourceBinding<Worker["Binding"]>>,
+): Effect.Effect<void, CloudflareTelemetryCompatibilityError> => {
+  const hasBind = bindings.some((b) => b.data.observability?.traces != null);
+  if (!hasBind) return Effect.void;
+  const { date } = getCompatibility(news);
+  if (date >= MIN_CLOUDFLARE_TRACING_DATE) return Effect.void;
+  return Effect.fail(
+    new CloudflareTelemetryCompatibilityError({
+      date,
+      minimumDate: MIN_CLOUDFLARE_TRACING_DATE,
+    }),
+  );
+};
+
+/**
+ * Mirror Effect spans into Cloudflare Workers Observability.
+ *
+ * A binding layer: at deploy time it turns on `observability.traces` on the
+ * host Worker (the same path as `Cloudflare.cache()`) and registers a
+ * per-event Effect Tracer. Cloudflare auto-instruments fetch/KV/R2/D1;
+ * `Effect.withSpan` / `Effect.fn` frames nest in that waterfall. Cloudflare
+ * owns sampling and export — no OTLP URL, flush, or Wrangler block.
+ *
+ * Until the global default compatibility date is raised past 2026-07-28,
+ * pin `compatibility: { date: "2026-08-25" }` (or later) or deploy fails.
+ * `alchemy dev` does not gate the date: what a local Worker records is the
+ * local runtime's concern.
+ *
+ * Compose it into the Function/Worker's single `Effect.provide`:
+ *
+ * ### Enabling native tracing
+ * **Example:** Effect spans in the Workers Observability waterfall
+ * ```typescript
+ * export default Cloudflare.Worker(
+ *   "Worker",
+ *   {
+ *     main: import.meta.url,
+ *     compatibility: { date: "2026-08-25" },
+ *   },
+ *   Effect.gen(function* () {
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         yield* doWork().pipe(Effect.withSpan("operation"));
+ *         return HttpServerResponse.text("ok");
+ *       }),
+ *     };
+ *   }).pipe(
+ *     Effect.provide(
+ *       Layer.mergeAll(
+ *         Cloudflare.R2.ReadWriteBucketBinding,
+ *         Cloudflare.Telemetry(),
+ *       ),
+ *     ),
+ *   ),
+ * );
+ * ```
+ *
+ * ### Combining with other exporters
+ * **Example:** Native traces plus another exporter's logs and metrics
+ * ```typescript
+ * Effect.provide(
+ *   Layer.mergeAll(
+ *     Cloudflare.Telemetry(),
+ *     // omit `traces` — Cloudflare.Telemetry provides the Tracer
+ *     Axiom.Telemetry({ token: Ingest, logs: Logs, metrics: Metrics }),
+ *   ),
+ * )
+ * ```
+ *
+ * To ship the same waterfall (Effect + platform spans) elsewhere, export
+ * it from Cloudflare with `Cloudflare.Workers.ObservabilityDestination`
+ * rather than sending a second Worker-side OTLP trace stream.
+ *
+ * @layer
+ * @provides Tracer.Tracer
+ * @product Workers
+ * @category Workers & Compute
+ */
+export const Telemetry = (
+  props: CloudflareTelemetryProps = {},
+): Layer.Layer<never, never, Worker> =>
+  Layer.unwrap(
+    Effect.gen(function* () {
+      const host = yield* Worker;
+      if (!globalThis.__ALCHEMY_RUNTIME__) {
+        yield* Namespace.push(
+          host.LogicalId,
+          host.bind("Cloudflare.Telemetry", {
+            observability: { traces: tracesFromProps(props) },
+          }),
+        );
+      }
+      // The runtime bridges build the registered Layer per event with a
+      // forked MemoMap, so the Tracer is naturally fresh per invocation.
+      return AlchemyTelemetry.layer(cloudflareTracerLayer);
+    }),
+  );

package/src/Cloudflare/Workers/ViteBuildChildRunner.ts

@@ -54,4 +54,9 @@ const program = Effect.gen(function* () {
   yield* fs.writeFile(config.outputPath, NodeV8.serialize(result));
 });
 
-runMain(program.pipe(Effect.provide(PlatformServices)));
+// The parent streams this child's output and turns its exit code into the
+// resource-scoped build error. Do not print a second Effect failure report
+// (the extra `✖` block) from the child itself.
+runMain(program.pipe(Effect.provide(PlatformServices)), {
+  disableErrorReporting: true,
+});

package/src/Cloudflare/Workers/ViteChild.shared.ts

@@ -27,6 +27,7 @@ export interface ViteChildConfig {
   source?: {
     descriptor: WorkerSourceDescriptor;
     id: string;
+    fqn: string;
     assets: WorkerAssetsConfig | undefined;
   };
   worker: {

package/src/Cloudflare/Workers/ViteChild.ts

@@ -11,14 +11,15 @@ import { fileURLToPath } from "node:url";
 import * as NodeV8 from "node:v8";
 import { AlchemyContext } from "../../AlchemyContext.ts";
 import { BundleError } from "../../Bundle/Bundle.ts";
+import { pipedColorEnv } from "../../Util/Terminal.ts";
 import {
   fromProcessEnv,
   RPC_SERVER_ENVIRONMENT_KEY,
   type RpcServerEnvironment,
 } from "../../Local/RpcServerEnvironment.ts";
 import { Stack } from "../../Stack.ts";
-import { transformTypesFlags } from "../../Util/Node.ts";
 import { unwrapRedacted } from "../../Util/index.ts";
+import { nodeLoaderArgs } from "../../Util/Node.ts";
 import {
   type ViteBuildChildConfig,
   type ViteBuildChildResult,
@@ -47,7 +48,7 @@ const resolveRunner = (basename: string) =>
 
 export const startViteChild = (
   config: ViteChildConfig,
-  onOutput: (channel: "stdout" | "stderr", line: string) => void,
+  onOutput: (channel: "stdout" | "stderr", line: string) => Effect.Effect<void>,
 ) =>
   Effect.gen(function* () {
     const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
@@ -96,21 +97,28 @@ export const startViteChild = (
         () => base.stack as { name: string; stage: string },
       ),
     };
+    const childEnv = {
+      ...process.env,
+      [RPC_SERVER_ENVIRONMENT_KEY]: JSON.stringify(childEnvironment),
+    };
+    // The parent CLI process sets NODE_ENV for its own React/renderer
+    // needs; that hack must not leak into the user's dev server (Vite
+    // derives its default mode from NODE_ENV, so an inherited value would
+    // silently override the project's own mode).
+    delete childEnv.NODE_ENV;
     const child = yield* spawner.spawn(
       ChildProcess.make(
         nodeExecPath ?? process.execPath,
         isBun && nodeExecPath === undefined
           ? ["run", runner]
-          : [...(runner.endsWith(".ts") ? transformTypesFlags() : []), runner],
+          : [...nodeLoaderArgs(runner), runner],
         {
           cwd: config.rootDir,
           stdin: Stream.succeed(serializedConfig),
           stdout: "pipe",
           stderr: "pipe",
-          env: {
-            [RPC_SERVER_ENVIRONMENT_KEY]: JSON.stringify(childEnvironment),
-          },
-          extendEnv: true,
+          env: childEnv,
+          extendEnv: false,
           killSignal: "SIGKILL",
         },
       ),
@@ -127,14 +135,14 @@ export const startViteChild = (
           const value = line.slice(start + VITE_CHILD_READY_PREFIX.length, end);
           return Deferred.succeed(ready, new URL(value));
         }
-        return Effect.sync(() => onOutput("stdout", line));
+        return onOutput("stdout", line);
       }),
       Effect.forkScoped,
     );
     yield* child.stderr.pipe(
       Stream.decodeText,
       Stream.splitLines,
-      Stream.runForEach((line) => Effect.sync(() => onOutput("stderr", line))),
+      Stream.runForEach((line) => onOutput("stderr", line)),
       Effect.forkScoped,
     );
 
@@ -170,7 +178,7 @@ const BUILD_ERROR_TAIL = 50;
  */
 export const runViteBuildChild = (
   config: Omit<ViteBuildChildConfig, "outputPath">,
-  onOutput: (channel: "stdout" | "stderr", line: string) => void,
+  onOutput: (channel: "stdout" | "stderr", line: string) => Effect.Effect<void>,
 ) =>
   Effect.scoped(
     Effect.gen(function* () {
@@ -191,12 +199,7 @@ export const runViteBuildChild = (
       const child = yield* spawner.spawn(
         ChildProcess.make(
           process.execPath,
-          isBun
-            ? ["run", runner]
-            : [
-                ...(runner.endsWith(".ts") ? transformTypesFlags() : []),
-                runner,
-              ],
+          isBun ? ["run", runner] : [...nodeLoaderArgs(runner), runner],
           {
             cwd: config.rootDir,
             stdin: Stream.succeed(serializedConfig),
@@ -208,7 +211,7 @@ export const runViteBuildChild = (
             // NODE_ENV=test) would otherwise bake `import.meta.env.DEV`
             // into the server bundle (e.g. SolidStart then ships its
             // dev-only manifest and every SSR request 500s).
-            env: { NODE_ENV: "production" },
+            env: { ...pipedColorEnv(), NODE_ENV: "production" },
             killSignal: "SIGKILL",
           },
         ),
@@ -219,8 +222,7 @@ export const runViteBuildChild = (
         Effect.sync(() => {
           tail.push(line);
           if (tail.length > BUILD_ERROR_TAIL) tail.shift();
-          onOutput(channel, line);
-        });
+        }).pipe(Effect.andThen(onOutput(channel, line)));
       const stdoutFiber = yield* Effect.forkChild(
         child.stdout.pipe(
           Stream.decodeText,

package/src/Cloudflare/Workers/ViteChildRunner.ts

@@ -94,11 +94,12 @@ const program = Effect.scoped(
           // module a fresh one.
           Effect.provideService(
             Artifacts,
-            makeScopedArtifacts(createArtifactStore(), source.id),
+            makeScopedArtifacts(createArtifactStore(), source.fqn),
           ),
           Effect.flatMap((provider) =>
             provider.dev({
               id: source.id,
+              fqn: source.fqn,
               workerName: config.worker.name,
               compatibility,
               entry: { kind: "external" },