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

package/lib/Cloudflare/Workers/LocalWorkerProvider.js

@@ -1,6 +1,7 @@
 import { Runtime, } from "@alchemy.run/cloudflare-runtime/core";
 import * as WorkerProxy from "@alchemy.run/cloudflare-runtime/core/proxy/WorkerProxy";
 import * as Cause from "effect/Cause";
+import * as ConsoleService from "effect/Console";
 import * as Effect from "effect/Effect";
 import * as Equal from "effect/Equal";
 import * as Exit from "effect/Exit";
@@ -14,6 +15,11 @@ import * as Scope from "effect/Scope";
 import * as Semaphore from "effect/Semaphore";
 import * as Stream from "effect/Stream";
 import * as os from "node:os";
+import { ANSI_RESET, ansiFg, colorsEnabled } from "../../Util/Terminal.js";
+import { theme } from "../../Util/Theme.js";
+import { formatResourceTag, makeResourceLogger, makeResourceOutput, } from "../../Util/ResourceOutput.js";
+import { makeDevLogDirectory, makeDevLogOpener } from "../../Local/DevLog.js";
+import { FQN_SEPARATOR } from "../../FQN.js";
 import * as LocalProvider from "../../Local/LocalProvider.js";
 import { Stack } from "../../Stack.js";
 import { unwrapRedacted } from "../../Util/index.js";
@@ -34,6 +40,19 @@ import { resolveTailConsumers } from "./WorkerProvider.js";
 import { materializeRuntimeBindings, WorkerValidationError, } from "./RuntimeBindings.js";
 import { startViteChild } from "./ViteChild.js";
 import { DEFAULT_DEV_PORT } from "./ViteChild.shared.js";
+const workerStartedMessage = (fqn, elapsed, url, logDir) => {
+    const duration = `${Math.round(elapsed)}ms`;
+    if (!colorsEnabled()) {
+        return `${formatResourceTag(fqn, false)} Started in ${duration} → ${url} (logs: ${logDir})`;
+    }
+    return `${formatResourceTag(fqn, true)} Started in ${ansiFg(theme.color.success)}${duration}${ANSI_RESET} → ${ansiFg(theme.color.info)}\x1b[4m${url}${ANSI_RESET} ${ansiFg(theme.color.muted)}(logs: ${logDir})${ANSI_RESET}`;
+};
+const workerUpdatedMessage = (fqn, elapsed) => {
+    const duration = `${Math.round(elapsed)}ms`;
+    return colorsEnabled()
+        ? `${formatResourceTag(fqn, true)} Updated in ${ansiFg(theme.color.success)}${duration}${ANSI_RESET}`
+        : `${formatResourceTag(fqn, false)} Updated in ${duration}`;
+};
 // Hosts that bind every interface — the dev server is then reachable at
 // `localhost` *and* at each LAN address, like Vite's `--host` output.
 const isWildcardHost = (host) => host === "0.0.0.0" || host === "::" || host === "[::]" || host === "*";
@@ -68,6 +87,17 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
     const runtime = yield* Runtime;
     const stack = yield* Stack;
     const storageDirectory = yield* localStorageDirectory;
+    const openDevLog = yield* makeDevLogOpener;
+    const devLogDir = yield* makeDevLogDirectory;
+    // Per-resource logs nest by FQN (log/{stage}/Site/Worker/…) so two
+    // workers sharing a logical id in different namespaces never share a
+    // directory.
+    const workerLogSegments = (worker) => [
+        stack.stage,
+        ...worker.fqn.split(FQN_SEPARATOR),
+    ];
+    const workerLogDir = (worker) => devLogDir(...workerLogSegments(worker));
+    const baseConsole = yield* ConsoleService.Console;
     const path = yield* Path.Path;
     const localRuntimeState = yield* LocalRuntimeState;
     const workerProxy = yield* WorkerProxy.WorkerProxy;
@@ -226,7 +256,7 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
      * reconciles drive restarts through the `workerRestarts` hook — they
      * are runtime wiring observed at start, not desired-state config.
      */
-    const resolveConfig = Effect.fn(function* ({ id, news, bindings, }) {
+    const resolveConfig = Effect.fn(function* ({ id, fqn, news, bindings, }) {
         const props = news;
         const name = yield* createWorkerName(id, props.name);
         const compatibility = getCompatibility(props);
@@ -328,6 +358,8 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
             };
         return {
             id,
+            /** Namespace-qualified id — the display prefix for every log line. */
+            fqn,
             name,
             compatibility,
             /** User env (Redacted preserved — the canonical hasher unwraps). */
@@ -430,12 +462,12 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
             stack: { name: stack.name, stage: stack.stage },
         });
     });
-    // Latest successful serve per worker id, so runtime wiring changes
+    // Latest successful serve per worker FQN, so runtime wiring changes
     // that arrive AFTER workerd started (e.g. a sibling `Consumer`
     // resource registering this script as a queue consumer) can restart
     // the instance with the same bundle.
     const latestServes = new Map();
-    // Serializes serves per worker id: a restart triggered by a sibling
+    // Serializes serves per worker FQN: a restart triggered by a sibling
     // resource may otherwise interleave with a rebuild-triggered serve
     // and leak a workerd scope.
     const serveLocks = new Map();
@@ -468,7 +500,7 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
     // serve completes. Ownership is tracked in `workerdScopes`, closed by
     // the next successful serve, by `delete`, or by provider shutdown.
     /**
-     * One container-context watcher per worker id, keyed by the watched
+     * One container-context watcher per worker FQN, keyed by the watched
      * path set. Registry-held (NOT per-serve-scope): a worker restarts
      * through several code paths that overlap scopes, and a watcher per
      * serve produced DUPLICATES whose simultaneous restarts storm the
@@ -516,11 +548,11 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
             });
         }
         const key = JSON.stringify([...watched.entries()].sort());
-        const existing = containerWatchers.get(worker.id);
+        const existing = containerWatchers.get(worker.fqn);
         if (existing !== undefined) {
             if (existing.key === key)
                 return; // same watcher keeps running
-            yield* stopContainerWatcher(worker.id);
+            yield* stopContainerWatcher(worker.fqn);
         }
         if (watched.size === 0)
             return;
@@ -564,26 +596,26 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
                 if (next === undefined || next === last)
                     return;
                 last = next;
-                yield* Effect.logInfo(`[${worker.id}] Container build context changed, restarting instance`);
+                yield* Effect.logInfo(`[${worker.fqn}] Container build context changed, restarting instance`);
                 yield* restart;
-            })), Effect.catchCause((cause) => Effect.logWarning(`[${worker.id}] Container context watch failed`, Cause.squash(cause))));
+            })), Effect.catchCause((cause) => Effect.logWarning(`[${worker.fqn}] Container context watch failed`, Cause.squash(cause))));
         });
         const fiber = yield* watchLoop.pipe(Effect.ensuring(Effect.sync(() => {
-            const current = containerWatchers.get(worker.id);
+            const current = containerWatchers.get(worker.fqn);
             if (current?.fiber === fiber) {
-                containerWatchers.delete(worker.id);
+                containerWatchers.delete(worker.fqn);
             }
         })), Effect.forkIn(rootScope));
-        containerWatchers.set(worker.id, { key, fiber });
+        containerWatchers.set(worker.fqn, { key, fiber });
     });
-    const serveWith = (worker, bundle, proxy) => Semaphore.withPermits(serveLock(worker.id), 1)(
+    const serveWith = (worker, bundle, proxy) => Semaphore.withPermits(serveLock(worker.fqn), 1)(
     // The bookkeeping around `runtime.start` must not be torn in half
     // by an interrupt: once a replacement workerd is up, it must be
     // recorded in `workerdScopes` and the superseded instances must be
     // closed, or one of the workerds would leak until provider
     // shutdown while holding the shared registry key.
     Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
-        const previous = workerdScopes.get(worker.id);
+        const previous = workerdScopes.get(worker.fqn);
         // Instances whose queue-consumer wiring went stale while they
         // were starting; never exposed via the proxy, closed together
         // with `previous` after the cutover below.
@@ -598,9 +630,31 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
         while (true) {
             const queueConsumers = yield* getQueueConsumers(worker.name);
             scope = yield* Scope.fork(rootScope);
+            // One log file per workerd generation, closed with its scope:
+            // log/{stage}/{fqn…}/{timestamp}.log. `logging.onOutput`
+            // REPLACES workerd's stdio inheritance, so this is the only
+            // path its output takes: raw chunks go to the file, complete
+            // lines go to the console with the worker's pnpm-style prefix.
+            const devLog = yield* openDevLog(...workerLogSegments(worker)).pipe(Scope.provide(scope));
+            // One splitter per channel: a shared buffer would splice a
+            // partial stdout line onto the next stderr chunk, and stderr
+            // would lose its severity on the way to the console.
+            const splitters = makeResourceOutput(worker.fqn, baseConsole);
+            yield* Scope.addFinalizer(scope, Effect.sync(() => {
+                splitters.stdout.flush();
+                splitters.stderr.flush();
+            }));
             url = yield* restore(runtime
                 .start({
                 name: worker.name,
+                logging: {
+                    // `(chunk, stream)` — chunk first; the stream name
+                    // indexes the splitters directly.
+                    onOutput: (chunk, stream) => {
+                        devLog.write(chunk);
+                        splitters[stream].push(chunk);
+                    },
+                },
                 compatibilityDate: worker.compatibility.date,
                 compatibilityFlags: worker.compatibility.flags,
                 bindings: worker.workerBindings,
@@ -639,16 +693,16 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
             Effect.onExit((exit) => exit._tag === "Failure"
                 ? Scope.close(scope, exit)
                 : Effect.void));
-            workerdScopes.set(worker.id, scope);
-            latestServes.set(worker.id, { worker, bundle, proxy });
+            workerdScopes.set(worker.fqn, scope);
+            latestServes.set(worker.fqn, { worker, bundle, proxy });
             // Register the restart hook before the re-check below: changes
             // landing after the re-check find the hook; changes before it
             // are caught by the re-check. Nothing falls in between.
-            MutableHashMap.set(localRuntimeState.workerRestarts, worker.name, restartWorker(worker.id));
-            // Idempotent: the registry keeps ONE watcher per worker id
+            MutableHashMap.set(localRuntimeState.workerRestarts, worker.name, restartWorker(worker.fqn));
+            // Idempotent: the registry keeps ONE watcher per worker FQN
             // across restarts (a new one only when the watched path set
             // changed).
-            yield* ensureContainerWatcher(worker, Effect.suspend(() => restartWorker(worker.id)));
+            yield* ensureContainerWatcher(worker, Effect.suspend(() => restartWorker(worker.fqn)));
             const currentConsumers = yield* getQueueConsumers(worker.name);
             if (JSON.stringify(currentConsumers) !==
                 JSON.stringify(queueConsumers)) {
@@ -668,7 +722,7 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
         for (const replaced of previous
             ? [...superseded, previous]
             : superseded) {
-            yield* Scope.close(replaced, Exit.void).pipe(Effect.catchCause((cause) => Effect.logWarning(`[${worker.id}] Failed to stop previous local worker instance`, Cause.squash(cause))));
+            yield* Scope.close(replaced, Exit.void).pipe(Effect.catchCause((cause) => Effect.logWarning(`[${worker.fqn}] Failed to stop previous local worker instance`, Cause.squash(cause))));
         }
         return url;
     })));
@@ -679,11 +733,11 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
      * served yet — the pending first serve will already observe the
      * updated state.
      */
-    const logRestartFailure = (id) => Effect.catchCause((cause) => Effect.logWarning(`[${id}] Failed to restart local worker`, Cause.squash(cause)));
+    const logRestartFailure = (fqn) => Effect.catchCause((cause) => Effect.logWarning(`[${fqn}] Failed to restart local worker`, Cause.squash(cause)));
     const restartWorker = (id) => Effect.suspend(() => {
         const latest = latestServes.get(id);
         if (latest) {
-            return serveWith(latest.worker, latest.bundle, latest.proxy).pipe(Effect.asVoid, logRestartFailure(id));
+            return serveWith(latest.worker, latest.bundle, latest.proxy).pipe(Effect.asVoid, logRestartFailure(latest.worker.fqn));
         }
         const vite = latestViteServes.get(id);
         if (vite) {
@@ -691,11 +745,11 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
             // child already serves the current wiring (the in-flight serve's
             // re-check loop may have picked it up while this restart waited
             // on the serve lock).
-            return serveVite(vite, { onlyIfConsumersChanged: true }).pipe(Effect.asVoid, logRestartFailure(id));
+            return serveVite(vite, { onlyIfConsumersChanged: true }).pipe(Effect.asVoid, logRestartFailure(vite.worker.fqn));
         }
         return Effect.void;
     });
-    // Tear down the running workerd for a worker id, if any. Used when the
+    // Tear down the running workerd for a worker FQN, if any. Used when the
     // Worker is deleted or handed off to an external dev process —
     // instance replacement does NOT go through this: the previous workerd
     // keeps serving until the replacement's first serve closes it.
@@ -737,7 +791,7 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
                 start = Date.now();
                 if (status === "update") {
                     return Effect.all([
-                        Effect.log(`[${worker.id}] Rebuilding`),
+                        Effect.log(`[${worker.fqn}] Rebuilding`),
                         // Tells the proxy to queue requests until the updated
                         // worker is ready.
                         Effect.forkChild(proxy.unset()),
@@ -745,25 +799,29 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
                 }
             }
             else if (event._tag === "Error") {
-                return Effect.logError(`[${worker.id}] Bundle error`, event.error);
+                return Effect.logError(`[${worker.fqn}] Bundle error`, event.error);
             }
             return Effect.void;
         }), Stream.filterMap((event) => event._tag === "Success"
             ? Result.succeed(event.output)
             : Result.failVoid), Stream.mapEffect((bundle) => serveWith(worker, bundle, proxy).pipe(Effect.exit, Effect.tap((exit) => {
             if (exit._tag === "Success") {
-                const message = Effect.log(`[${worker.id}] ${status === "update" ? "Updated" : "Started"} in ${Math.round(Date.now() - start)}ms`);
+                // URL on first start only — vite-banner style; rebuild
+                // lines stay compact.
+                const message = Effect.log(status === "update"
+                    ? workerUpdatedMessage(worker.fqn, Date.now() - start)
+                    : workerStartedMessage(worker.fqn, Date.now() - start, proxy.url, workerLogDir(worker)));
                 status = "update";
                 return message;
             }
             else {
-                return Effect.logError(`[${worker.id}] Error`, Cause.squash(exit.cause));
+                return Effect.logError(`[${worker.fqn}] Error`, Cause.squash(exit.cause));
             }
         }))), Stream.runDrain, Effect.forkScoped);
     });
     const runWorker = Effect.fn(function* (worker) {
         const start = Date.now();
-        const proxy = yield* maybeStartProxy(worker.id, worker.dev);
+        const proxy = yield* maybeStartProxy(worker.fqn, worker.dev);
         // Inline `script` workers bypass the bundler entirely — the string
         // IS the module (mirroring the deploy path, which uploads it as a
         // single `main.js`). There is nothing to watch: script changes flow
@@ -773,12 +831,13 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
                 files: [{ path: "main.js", content: worker.script, hash: "" }],
                 hash: "",
             }, proxy);
-            yield* Effect.log(`[${worker.id}] Started in ${Math.round(Date.now() - start)}ms → ${proxy.url}`);
+            yield* Effect.log(workerStartedMessage(worker.fqn, Date.now() - start, proxy.url, workerLogDir(worker)));
             return proxy.url;
         }
         const bundles = isPythonMain(worker.bundleOptions.main)
             ? watchPythonWorkerBundle({
                 id: worker.bundleOptions.id,
+                fqn: worker.fqn,
                 main: worker.bundleOptions.main,
                 compatibility: worker.compatibility,
             })
@@ -813,9 +872,9 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
     };
     const runAssetsOnly = Effect.fn(function* (worker) {
         const start = Date.now();
-        const proxy = yield* maybeStartProxy(worker.id, worker.dev);
+        const proxy = yield* maybeStartProxy(worker.fqn, worker.dev);
         yield* serveWith(worker, assetsOnlyBundle, proxy);
-        yield* Effect.log(`[${worker.id}] Started in ${Math.round(Date.now() - start)}ms`);
+        yield* Effect.log(workerStartedMessage(worker.fqn, Date.now() - start, proxy.url, workerLogDir(worker)));
         return proxy.url;
     });
     /** The Vite analogue of `latestServes`: everything needed to restart
@@ -836,7 +895,7 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
     // `rootScope` and tracked in `workerdScopes`, so it survives instance
     // restarts and is reclaimed by `stop`/handoff/`serveWith` like any
     // other running instance.
-    const serveVite = (args, options) => Semaphore.withPermits(serveLock(args.worker.id), 1)(
+    const serveVite = (args, options) => Semaphore.withPermits(serveLock(args.worker.fqn), 1)(
     // The bookkeeping around `startViteChild` must not be torn in half
     // by an interrupt: once a replacement child is up it must be
     // recorded in `workerdScopes`, or it would leak until provider
@@ -845,8 +904,9 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
         const { worker, rootDir, invalidate, source, proxy } = args;
         if (options?.onlyIfConsumersChanged) {
             const current = yield* getQueueConsumers(worker.name);
-            if (workerdScopes.has(worker.id) &&
-                JSON.stringify(current) === servedViteConsumers.get(worker.id)) {
+            if (workerdScopes.has(worker.fqn) &&
+                JSON.stringify(current) ===
+                    servedViteConsumers.get(worker.fqn)) {
                 return;
             }
         }
@@ -866,8 +926,10 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
             // Break-before-make: tear the previous child down before
             // starting its replacement (also covers a superseded child
             // from the previous loop iteration).
-            yield* closeWorkerd(worker.id);
+            yield* closeWorkerd(worker.fqn);
             const scope = yield* Scope.fork(rootScope);
+            const devLog = yield* openDevLog(...workerLogSegments(worker)).pipe(Scope.provide(scope));
+            const logResourceOutput = makeResourceLogger(worker.fqn);
             const child = yield* restore(startViteChild({
                 rootDir: root,
                 publicUrl: proxy.url.toString().replace(/\/$/, ""),
@@ -895,27 +957,25 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
                     queueConsumers,
                     assets: yield* toRuntimeAssets(worker.assets),
                 },
-            }, (channel, line) => {
-                process[channel].write(`${worker.id} | ${line}\n`);
-            }).pipe(Scope.provide(scope))).pipe(
+            }, (channel, line) => logResourceOutput(channel, line).pipe(Effect.andThen(Effect.sync(() => devLog.writeLine(line))))).pipe(Scope.provide(scope))).pipe(
             // The scope hangs off `rootScope`, so a failed or
             // interrupted start must close it here — nothing else owns
             // it yet.
             Effect.onExit((exit) => exit._tag === "Failure"
                 ? Scope.close(scope, exit)
                 : Effect.void));
-            workerdScopes.set(worker.id, scope);
-            latestViteServes.set(worker.id, args);
+            workerdScopes.set(worker.fqn, scope);
+            latestViteServes.set(worker.fqn, args);
             // Unexpected child death: log, park the proxy, and mark the
             // instance for update on the next plan. Forked into the
             // child's scope so a deliberate restart or teardown
             // interrupts the watcher before the process is killed.
-            yield* child.exitCode.pipe(Effect.flatMap((exitCode) => Effect.logWarning(`[${worker.id}] Dev server child exited unexpectedly with code ${exitCode}`)), Effect.andThen(proxy.unset().pipe(Effect.ignore)), Effect.andThen(invalidate), Effect.forkIn(scope));
+            yield* child.exitCode.pipe(Effect.flatMap((exitCode) => Effect.logWarning(`[${worker.fqn}] Dev server child exited unexpectedly with code ${exitCode}`)), Effect.andThen(proxy.unset().pipe(Effect.ignore)), Effect.andThen(invalidate), Effect.forkIn(scope));
             // Register the restart hook before the re-check below:
             // changes landing after the re-check find the hook; changes
             // before it are caught by the re-check. Nothing falls in
             // between.
-            MutableHashMap.set(localRuntimeState.workerRestarts, worker.name, restartWorker(worker.id));
+            MutableHashMap.set(localRuntimeState.workerRestarts, worker.name, restartWorker(worker.fqn));
             const currentConsumers = yield* getQueueConsumers(worker.name);
             if (JSON.stringify(currentConsumers) !==
                 JSON.stringify(queueConsumers)) {
@@ -923,14 +983,19 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
                 // again with the fresh consumers before exposing it.
                 continue;
             }
-            servedViteConsumers.set(worker.id, JSON.stringify(queueConsumers));
+            servedViteConsumers.set(worker.fqn, JSON.stringify(queueConsumers));
             yield* proxy.set(child.url);
             return;
         }
     })));
     const runVite = Effect.fn(function* (worker, rootDir, invalidate, source) {
-        const proxy = yield* maybeStartProxy(worker.id, worker.dev);
+        const start = Date.now();
+        const proxy = yield* maybeStartProxy(worker.fqn, worker.dev);
         yield* serveVite({ worker, rootDir, invalidate, source, proxy });
+        // The programmatic vite API never prints the CLI's URL banner — and
+        // vite's own URL is the internal (port-shuffled) server behind the
+        // stable proxy, so advertise the proxy instead.
+        yield* Effect.log(workerStartedMessage(worker.fqn, Date.now() - start, proxy.url, workerLogDir(worker)));
         return proxy.url;
     });
     // External source provider (`props.source`): the provider owns the
@@ -941,7 +1006,7 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
     //   bundle is served through the same make-before-break `serveWith`
     //   path the built-in bundler uses.
     const runSource = Effect.fn(function* (worker) {
-        const proxy = yield* maybeStartProxy(worker.id, worker.dev);
+        const proxy = yield* maybeStartProxy(worker.fqn, worker.dev);
         // Queue requests until the source's first output is served —
         // whether that's the first workerd serve (bundle mode) or the dev
         // server URL (server mode).
@@ -950,9 +1015,10 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
         // (which includes the per-run Artifacts cache the live provider
         // supplies); local dev has no run-scoped cache, so hand the
         // module a fresh in-memory one.
-        const source = yield* loadSource(worker.source).pipe(Effect.provideService(AlchemyArtifacts, makeScopedArtifacts(createArtifactStore(), worker.id)));
+        const source = yield* loadSource(worker.source).pipe(Effect.provideService(AlchemyArtifacts, makeScopedArtifacts(createArtifactStore(), worker.fqn)));
         const devCtx = {
             id: worker.id,
+            fqn: worker.fqn,
             workerName: worker.name,
             compatibility: worker.compatibility,
             entry: worker.bundleOptions.entry,
@@ -985,7 +1051,7 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
         stables: ({ output, config }) => Effect.succeed(output?.workerName === config.name
             ? ["workerName"]
             : undefined),
-        precreate: Effect.fn(function* ({ id, news, bindings }) {
+        precreate: Effect.fn(function* ({ id, fqn, news, bindings }) {
             const name = yield* createWorkerName(id, news.name);
             const durableObjectNamespaces = {};
             for (const { data } of bindings) {
@@ -1001,7 +1067,7 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
             const urls = news.dev?.mode === "external"
                 ? // news.dev.url may be an unresolved output; avoid trying to resolve it here.
                     []
-                : yield* maybeStartProxy(id, {
+                : yield* maybeStartProxy(fqn, {
                     ...news.dev,
                     mode: "worker",
                     port: news.dev?.port ?? DEFAULT_DEV_PORT,
@@ -1024,19 +1090,19 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
                 accountId,
             };
         }),
-        start: Effect.fn(function* ({ id, config, invalidate }) {
+        start: Effect.fn(function* ({ fqn, config, invalidate }) {
             const { accountId } = yield* cloudflareEnv;
             // `dev: { mode: "external" }` opts out of running a local Worker
             // entirely — typically because an external dev process
             // (Command.Dev) is serving requests. The instance exists in the
             // registry (with an empty scope) but has no workerd behind it. A
-            // previous worker-mode instance for this id may have registered
+            // previous worker-mode instance for this FQN may have registered
             // serve/restart state — drop it, and tear down its workerd (with
             // make-before-break the running workerd outlives instance scopes
             // and must be closed explicitly on handoff).
             if (config.dev.mode === "external") {
-                dropServeState(id);
-                yield* closeWorkerd(id);
+                dropServeState(fqn);
+                yield* closeWorkerd(fqn);
                 const urls = config.dev.url ? [config.dev.url] : [];
                 return {
                     workerId: `dev:${config.name}`,
@@ -1056,13 +1122,13 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
                 };
             }
             // `Worker.URL` locally resolves to the worker's dev-proxy URL —
-            // the proxy is stable per worker id (the same instance `runWorker`
+            // the proxy is stable per worker FQN (the same instance `runWorker`
             // / `runVite` attach to below), so the URL is known before workerd
             // starts. Trailing slash stripped to match the cloud value's shape.
             const needsSelfUrl = config.bindingDescriptors.some((b) => b.type === "self_url") ||
                 Object.values(config.env ?? {}).some(isSelfUrl);
             const selfUrl = needsSelfUrl
-                ? (yield* maybeStartProxy(id, config.dev)).url
+                ? (yield* maybeStartProxy(fqn, config.dev)).url
                     .toString()
                     .replace(/\/$/, "")
                 : undefined;
@@ -1087,6 +1153,7 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
                     ? runVite(worker, config.source.rootDir, invalidate, {
                         descriptor: config.source,
                         id: worker.id,
+                        fqn: worker.fqn,
                         assets: worker.assets,
                     })
                     : runSource(worker)
@@ -1119,14 +1186,14 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
                 accountId,
             };
         }),
-        stop: Effect.fn(function* ({ id }) {
+        stop: Effect.fn(function* ({ fqn }) {
             // Cross-restart state: the serve/restart bookkeeping, the running
             // workerd (which outlives instance scopes for make-before-break),
             // and the URL proxy live outside instance scopes and are only
             // reclaimed on a real delete.
-            dropServeState(id);
-            yield* closeWorkerd(id);
-            yield* stopProxy(id);
+            dropServeState(fqn);
+            yield* closeWorkerd(fqn);
+            yield* stopProxy(fqn);
         }),
     };
 }));