@confect/cli 1.0.0-next.3 → 1.0.0-next.4

package/src/confect/dev.ts

@@ -5,7 +5,7 @@ import { Ansi, AnsiDoc } from "@effect/printer-ansi";
 import {
   Array,
   Console,
-  Data,
+  Deferred,
   Duration,
   Effect,
   Equal,
@@ -25,7 +25,7 @@ import * as tsx from "tsx/esm/api";
 import type * as FunctionPath from "../FunctionPath";
 import * as FunctionPaths from "../FunctionPaths";
 import * as GroupPath from "../GroupPath";
-import { logCompleted, logFailed } from "../log";
+import { logFailure, logPending, logSuccess } from "../log";
 import { ConfectDirectory } from "../services/ConfectDirectory";
 import { ConvexDirectory } from "../services/ConvexDirectory";
 import { ProjectRoot } from "../services/ProjectRoot";
@@ -37,10 +37,15 @@ import {
   removeGroups,
   writeGroups,
 } from "../utils";
-import { codegenHandler } from "./codegen";
+import {
+  codegenHandler,
+  generateNodeApi,
+  generateNodeRegisteredFunctions,
+} from "./codegen";
 
 type Pending = {
   readonly specDirty: boolean;
+  readonly nodeImplDirty: boolean;
   readonly httpDirty: boolean;
   readonly appDirty: boolean;
   readonly cronsDirty: boolean;
@@ -49,56 +54,13 @@ type Pending = {
 
 const pendingInit: Pending = {
   specDirty: false,
+  nodeImplDirty: false,
   httpDirty: false,
   appDirty: false,
   cronsDirty: false,
   authDirty: false,
 };
 
-type FileChange = Data.TaggedEnum<{
-  OptionalFile: {
-    readonly change: "Added" | "Removed" | "Modified";
-    readonly filePath: string;
-  };
-  GroupModule: {
-    readonly change: "Added" | "Removed" | "Modified";
-    readonly filePath: string;
-    readonly functionsAdded: ReadonlyArray<FunctionPath.FunctionPath>;
-    readonly functionsRemoved: ReadonlyArray<FunctionPath.FunctionPath>;
-  };
-}>;
-
-const FileChange = Data.taggedEnum<FileChange>();
-
-const logChangeReport = (changes: ReadonlyArray<FileChange>) =>
-  Effect.gen(function* () {
-    yield* logCompleted("Generated files are up-to-date");
-
-    yield* Effect.when(
-      Effect.forEach(changes, (change) =>
-        FileChange.$match(change, {
-          OptionalFile: ({ change: c, filePath }) =>
-            logFileChangeIndented(c, filePath),
-          GroupModule: ({
-            change: c,
-            filePath,
-            functionsAdded,
-            functionsRemoved,
-          }) =>
-            Effect.gen(function* () {
-              yield* logFileChangeIndented(c, filePath);
-              yield* Effect.forEach(functionsAdded, logFunctionAddedIndented);
-              yield* Effect.forEach(
-                functionsRemoved,
-                logFunctionRemovedIndented,
-              );
-            }),
-        }),
-      ),
-      () => Array.isNonEmptyReadonlyArray(changes),
-    );
-  });
-
 const changeChar = (change: "Added" | "Removed" | "Modified") =>
   Match.value(change).pipe(
     Match.when("Added", () => ({ char: "+", color: Ansi.green })),
@@ -124,8 +86,8 @@ const logFileChangeIndented = (
 
     yield* Console.log(
       pipe(
-        AnsiDoc.text("  "),
-        AnsiDoc.cat(pipe(AnsiDoc.char(char), AnsiDoc.annotate(color))),
+        AnsiDoc.char(char),
+        AnsiDoc.annotate(color),
         AnsiDoc.catWithSpace(
           AnsiDoc.hcat([
             pipe(AnsiDoc.text(prefix), AnsiDoc.annotate(Ansi.blackBright)),
@@ -140,7 +102,7 @@ const logFileChangeIndented = (
 const logFunctionAddedIndented = (functionPath: FunctionPath.FunctionPath) =>
   Console.log(
     pipe(
-      AnsiDoc.text("    "),
+      AnsiDoc.text("  "),
       AnsiDoc.cat(pipe(AnsiDoc.char("+"), AnsiDoc.annotate(Ansi.green))),
       AnsiDoc.catWithSpace(
         AnsiDoc.hcat([
@@ -158,7 +120,7 @@ const logFunctionAddedIndented = (functionPath: FunctionPath.FunctionPath) =>
 const logFunctionRemovedIndented = (functionPath: FunctionPath.FunctionPath) =>
   Console.log(
     pipe(
-      AnsiDoc.text("    "),
+      AnsiDoc.text("  "),
       AnsiDoc.cat(pipe(AnsiDoc.char("-"), AnsiDoc.annotate(Ansi.red))),
       AnsiDoc.catWithSpace(
         AnsiDoc.hcat([
@@ -175,15 +137,17 @@ const logFunctionRemovedIndented = (functionPath: FunctionPath.FunctionPath) =>
 
 export const dev = Command.make("dev", {}, () =>
   Effect.gen(function* () {
+    yield* logPending("Performing initial sync…");
     const initialFunctionPaths = yield* codegenHandler;
 
     const pendingRef = yield* Ref.make<Pending>(pendingInit);
     const signal = yield* Queue.sliding<void>(1);
+    const specWatcherRestartQueue = yield* Queue.sliding<void>(1);
 
     yield* Effect.all(
       [
-        specFileWatcher(signal, pendingRef),
-        confectDirectoryWatcher(signal, pendingRef),
+        specFileWatcher(signal, pendingRef, specWatcherRestartQueue),
+        confectDirectoryWatcher(signal, pendingRef, specWatcherRestartQueue),
         syncLoop(signal, pendingRef, initialFunctionPaths),
       ],
       { concurrency: "unbounded" },
@@ -198,17 +162,30 @@ const syncLoop = (
 ) =>
   Effect.gen(function* () {
     const functionPathsRef = yield* Ref.make(initialFunctionPaths);
-    const changesRef = yield* Ref.make<ReadonlyArray<FileChange>>([]);
+    const initialSyncDone = yield* Deferred.make<void>();
 
     return yield* Effect.forever(
       Effect.gen(function* () {
         yield* Effect.logDebug("Running sync loop...");
         yield* Queue.take(signal);
 
+        const isDone = yield* Deferred.isDone(initialSyncDone);
+        yield* Effect.when(
+          logPending("Dependencies changed, reloading…"),
+          () => isDone,
+        );
+        yield* Deferred.succeed(initialSyncDone, undefined);
+
         const pending = yield* Ref.getAndSet(pendingRef, pendingInit);
 
-        const specResult: Option.Option<ReadonlyArray<FileChange>> =
-          yield* Effect.if(pending.specDirty, {
+        if (pending.specDirty || pending.nodeImplDirty) {
+          yield* generateNodeApi;
+          yield* generateNodeRegisteredFunctions;
+        }
+
+        const specResult: Option.Option<void> = yield* Effect.if(
+          pending.specDirty,
+          {
             onTrue: () =>
               loadSpec.pipe(
                 Effect.andThen(
@@ -231,104 +208,102 @@ const syncLoop = (
 
                     // Removed groups
                     yield* removeGroups(groupsRemoved);
-                    const removedChanges = yield* Effect.forEach(
-                      groupsRemoved,
-                      (gp) =>
-                        Effect.gen(function* () {
-                          const relativeModulePath =
-                            yield* GroupPath.modulePath(gp);
-                          return FileChange.GroupModule({
-                            change: "Removed",
-                            filePath: path.join(
-                              convexDirectory,
-                              relativeModulePath,
-                            ),
-                            functionsAdded: [],
-                            functionsRemoved: Array.fromIterable(
-                              HashSet.filter(functionsRemoved, (fp) =>
-                                Equal.equals(fp.groupPath, gp),
-                              ),
+                    yield* Effect.forEach(groupsRemoved, (gp) =>
+                      Effect.gen(function* () {
+                        const relativeModulePath =
+                          yield* GroupPath.modulePath(gp);
+                        const filePath = path.join(
+                          convexDirectory,
+                          relativeModulePath,
+                        );
+                        yield* logFileChangeIndented("Removed", filePath);
+                        yield* Effect.forEach(
+                          Array.fromIterable(
+                            HashSet.filter(functionsRemoved, (fp) =>
+                              Equal.equals(fp.groupPath, gp),
                             ),
-                          });
-                        }),
+                          ),
+                          logFunctionRemovedIndented,
+                        );
+                      }),
                     );
 
                     // Added groups
                     yield* writeGroups(spec, groupsAdded);
-                    const addedChanges = yield* Effect.forEach(
-                      groupsAdded,
-                      (gp) =>
-                        Effect.gen(function* () {
-                          const relativeModulePath =
-                            yield* GroupPath.modulePath(gp);
-                          return FileChange.GroupModule({
-                            change: "Added",
-                            filePath: path.join(
-                              convexDirectory,
-                              relativeModulePath,
-                            ),
-                            functionsAdded: Array.fromIterable(
-                              HashSet.filter(functionsAdded, (fp) =>
-                                Equal.equals(fp.groupPath, gp),
-                              ),
+                    yield* Effect.forEach(groupsAdded, (gp) =>
+                      Effect.gen(function* () {
+                        const relativeModulePath =
+                          yield* GroupPath.modulePath(gp);
+                        const filePath = path.join(
+                          convexDirectory,
+                          relativeModulePath,
+                        );
+                        yield* logFileChangeIndented("Added", filePath);
+                        yield* Effect.forEach(
+                          Array.fromIterable(
+                            HashSet.filter(functionsAdded, (fp) =>
+                              Equal.equals(fp.groupPath, gp),
                             ),
-                            functionsRemoved: [],
-                          });
-                        }),
+                          ),
+                          logFunctionAddedIndented,
+                        );
+                      }),
                     );
 
                     // Changed groups
                     yield* writeGroups(spec, groupsChanged);
-                    const changedChanges = yield* Effect.forEach(
-                      groupsChanged,
-                      (gp) =>
-                        Effect.gen(function* () {
-                          const relativeModulePath =
-                            yield* GroupPath.modulePath(gp);
-                          return FileChange.GroupModule({
-                            change: "Modified",
-                            filePath: path.join(
-                              convexDirectory,
-                              relativeModulePath,
-                            ),
-                            functionsAdded: Array.fromIterable(
-                              HashSet.filter(functionsAdded, (fp) =>
-                                Equal.equals(fp.groupPath, gp),
-                              ),
+                    yield* Effect.forEach(groupsChanged, (gp) =>
+                      Effect.gen(function* () {
+                        const relativeModulePath =
+                          yield* GroupPath.modulePath(gp);
+                        const filePath = path.join(
+                          convexDirectory,
+                          relativeModulePath,
+                        );
+                        yield* logFileChangeIndented("Modified", filePath);
+                        yield* Effect.forEach(
+                          Array.fromIterable(
+                            HashSet.filter(functionsAdded, (fp) =>
+                              Equal.equals(fp.groupPath, gp),
                             ),
-                            functionsRemoved: Array.fromIterable(
-                              HashSet.filter(functionsRemoved, (fp) =>
-                                Equal.equals(fp.groupPath, gp),
-                              ),
+                          ),
+                          logFunctionAddedIndented,
+                        );
+                        yield* Effect.forEach(
+                          Array.fromIterable(
+                            HashSet.filter(functionsRemoved, (fp) =>
+                              Equal.equals(fp.groupPath, gp),
                             ),
-                          });
-                        }),
+                          ),
+                          logFunctionRemovedIndented,
+                        );
+                      }),
                     );
 
                     yield* Ref.set(functionPathsRef, current);
 
-                    return Option.some([
-                      ...removedChanges,
-                      ...addedChanges,
-                      ...changedChanges,
-                    ]);
+                    return Option.some(undefined);
                   }),
                 ),
                 Effect.catchTag("SpecImportFailedError", () =>
-                  logFailed("Spec import failed").pipe(
+                  logFailure("Spec import failed").pipe(
                     Effect.as(Option.none()),
                   ),
                 ),
                 Effect.catchTag("SpecFileDoesNotExportSpecError", () =>
-                  logFailed("Spec file does not default export a spec").pipe(
-                    Effect.as(Option.none()),
-                  ),
+                  logFailure(
+                    "Spec file does not default export a Convex spec",
+                  ).pipe(Effect.as(Option.none())),
+                ),
+                Effect.catchTag("NodeSpecFileDoesNotExportSpecError", () =>
+                  logFailure(
+                    "Node spec file does not default export a Node spec",
+                  ).pipe(Effect.as(Option.none())),
                 ),
               ),
-            onFalse: () => Effect.succeed(Option.some([])),
-          });
-
-        const specChanges = Option.getOrElse(specResult, () => []);
+            onFalse: () => Effect.succeed(Option.some(undefined)),
+          },
+        );
 
         const dirtyOptionalFiles = [
           ...(pending.httpDirty
@@ -345,42 +320,22 @@ const syncLoop = (
             : []),
         ];
 
-        const optionalChanges: ReadonlyArray<FileChange> =
-          Array.isNonEmptyReadonlyArray(dirtyOptionalFiles)
-            ? yield* pipe(
-                Effect.all(dirtyOptionalFiles, {
-                  concurrency: "unbounded",
-                }),
-                Effect.map(Array.getSomes),
-              )
-            : [];
-
-        yield* Ref.update(changesRef, (prev) => [
-          ...prev,
-          ...specChanges,
-          ...optionalChanges,
-        ]);
+        yield* Array.isNonEmptyReadonlyArray(dirtyOptionalFiles)
+          ? Effect.all(dirtyOptionalFiles, { concurrency: "unbounded" })
+          : Effect.void;
 
         yield* Option.match(specResult, {
-          onSome: () =>
-            Effect.gen(function* () {
-              const pendingSize = yield* Queue.size(signal);
-              yield* Effect.when(
-                Effect.gen(function* () {
-                  const allChanges = yield* Ref.getAndSet(changesRef, []);
-                  yield* logChangeReport(allChanges);
-                }),
-                () => pendingSize === 0,
-              );
-            }),
-          onNone: () => Ref.set(changesRef, []),
+          onSome: () => logSuccess("Generated files are up-to-date"),
+          onNone: () => Effect.void,
         });
       }),
     );
   });
 
 const loadSpec = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
+  const confectDirectory = yield* ConfectDirectory.get;
   const specPathUrl = yield* path.toFileUrl(yield* getSpecPath);
   const specModule = yield* Effect.tryPromise({
     try: () => tsx.tsImport(specPathUrl.href, import.meta.url),
@@ -388,11 +343,19 @@ const loadSpec = Effect.gen(function* () {
   });
   const spec = specModule.default;
 
-  if (Spec.isSpec(spec)) {
-    return spec;
-  } else {
-    return yield* Effect.fail(new SpecFileDoesNotExportSpecError());
+  if (!Spec.isConvexSpec(spec)) {
+    return yield* new SpecFileDoesNotExportSpecError();
   }
+
+  const nodeImplPath = path.join(confectDirectory, "nodeImpl.ts");
+  const nodeImplExists = yield* fs.exists(nodeImplPath);
+  const nodeSpecOption = yield* loadNodeSpec;
+  const mergedSpec = Option.match(nodeSpecOption, {
+    onNone: () => spec,
+    onSome: (nodeSpec) => (nodeImplExists ? Spec.merge(spec, nodeSpec) : spec),
+  });
+
+  return mergedSpec;
 });
 
 const getSpecPath = Effect.gen(function* () {
@@ -402,87 +365,152 @@ const getSpecPath = Effect.gen(function* () {
   return path.join(confectDirectory, "spec.ts");
 });
 
+const getNodeSpecPath = Effect.gen(function* () {
+  const path = yield* Path.Path;
+  const confectDirectory = yield* ConfectDirectory.get;
+
+  return path.join(confectDirectory, "nodeSpec.ts");
+});
+
+const loadNodeSpec = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const nodeSpecPath = yield* getNodeSpecPath;
+
+  if (!(yield* fs.exists(nodeSpecPath))) {
+    return Option.none();
+  }
+
+  const nodeSpecPathUrl = yield* path.toFileUrl(nodeSpecPath);
+  const nodeSpecModule = yield* Effect.tryPromise({
+    try: () => tsx.tsImport(nodeSpecPathUrl.href, import.meta.url),
+    catch: (error) => new SpecImportFailedError({ error }),
+  });
+  const nodeSpec = nodeSpecModule.default;
+
+  if (!Spec.isNodeSpec(nodeSpec)) {
+    return yield* new NodeSpecFileDoesNotExportSpecError();
+  }
+
+  return Option.some(nodeSpec);
+});
+
+const esbuildOptions = (entryPoint: string) => ({
+  entryPoints: [entryPoint],
+  bundle: true,
+  write: false,
+  metafile: true,
+  platform: "node" as const,
+  format: "esm" as const,
+  logLevel: "silent" as const,
+  external: ["@confect/core", "@confect/server", "effect", "@effect/*"],
+  plugins: [
+    {
+      name: "notify-rebuild",
+      setup(build: esbuild.PluginBuild) {
+        build.onEnd((result) => {
+          if (result.errors.length === 0) {
+            (build as { _emit?: (v: void) => void })._emit?.();
+          } else {
+            Effect.runPromise(
+              Effect.gen(function* () {
+                const formattedMessages = yield* Effect.promise(() =>
+                  esbuild.formatMessages(result.errors, {
+                    kind: "error",
+                    color: true,
+                    terminalWidth: 80,
+                  }),
+                );
+                const output = formatBuildErrors(
+                  result.errors,
+                  formattedMessages,
+                );
+                yield* Console.error("\n" + output + "\n");
+                yield* logFailure("Build errors found");
+              }),
+            );
+          }
+        });
+      },
+    },
+  ],
+});
+
+const createSpecWatcher = (entryPoint: string) =>
+  Stream.asyncPush<void>(
+    (emit) =>
+      Effect.acquireRelease(
+        Effect.promise(async () => {
+          const opts = esbuildOptions(entryPoint);
+          const plugin = opts.plugins[0];
+          const originalSetup = plugin!.setup!;
+          (plugin as { setup: (build: esbuild.PluginBuild) => void }).setup = (
+            build,
+          ) => {
+            (build as { _emit?: (v: void) => void })._emit = () =>
+              emit.single();
+            return originalSetup(build);
+          };
+
+          const ctx = await esbuild.context({
+            ...opts,
+            plugins: [plugin],
+          });
+
+          await ctx.watch();
+          return ctx;
+        }),
+        (ctx) =>
+          Effect.promise(() => ctx.dispose()).pipe(
+            Effect.tap(() => Effect.logDebug("esbuild watcher disposed")),
+          ),
+      ),
+    { bufferSize: 1, strategy: "sliding" },
+  );
+
+type SpecWatcherEvent = "change" | "restart";
+
 const specFileWatcher = (
   signal: Queue.Queue<void>,
   pendingRef: Ref.Ref<Pending>,
+  specWatcherRestartQueue: Queue.Queue<void>,
 ) =>
-  Effect.gen(function* () {
-    const specPath = yield* getSpecPath;
-
-    const specChanges: Stream.Stream<void> = Stream.asyncPush(
-      (emit) =>
-        Effect.acquireRelease(
-          Effect.promise(async () => {
-            const ctx = await esbuild.context({
-              entryPoints: [specPath],
-              bundle: true,
-              write: false,
-              metafile: true,
-              platform: "node",
-              format: "esm",
-              logLevel: "silent",
-              external: [
-                "@confect/core",
-                "@confect/server",
-                "effect",
-                "@effect/*",
-              ],
-              plugins: [
-                {
-                  name: "notify-rebuild",
-                  setup(build) {
-                    build.onEnd((result) => {
-                      if (result.errors.length === 0) {
-                        emit.single();
-                      } else {
-                        Effect.runPromise(
-                          Effect.gen(function* () {
-                            yield* logFailed("Build errors");
-                            const formattedMessages = yield* Effect.promise(
-                              () =>
-                                esbuild.formatMessages(result.errors, {
-                                  kind: "error",
-                                  color: true,
-                                  terminalWidth: 80,
-                                }),
-                            );
-                            const output = formatBuildErrors(
-                              result.errors,
-                              formattedMessages,
-                            );
-                            yield* Console.error("\n" + output + "\n");
-                          }),
-                        );
-                      }
-                    });
-                  },
-                },
-              ],
-            });
-
-            await ctx.watch();
-
-            return ctx;
-          }),
-          (ctx) =>
-            Effect.promise(() => ctx.dispose()).pipe(
-              Effect.tap(() => Effect.logDebug("esbuild watcher disposed")),
-            ),
+  Effect.forever(
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const specPath = yield* getSpecPath;
+      const nodeSpecPath = yield* getNodeSpecPath;
+      const nodeSpecExists = yield* fs.exists(nodeSpecPath);
+
+      const specWatcher = createSpecWatcher(specPath);
+      const nodeSpecWatcher = nodeSpecExists
+        ? createSpecWatcher(nodeSpecPath)
+        : Stream.empty;
+
+      const specChanges = pipe(
+        Stream.merge(specWatcher, nodeSpecWatcher),
+        Stream.map((): SpecWatcherEvent => "change"),
+      );
+      const restartStream = pipe(
+        Stream.fromQueue(specWatcherRestartQueue),
+        Stream.map((): SpecWatcherEvent => "restart"),
+      );
+
+      yield* pipe(
+        Stream.merge(specChanges, restartStream),
+        Stream.debounce(Duration.millis(200)),
+        Stream.takeUntil((event): event is "restart" => event === "restart"),
+        Stream.runForEach((event) =>
+          event === "change"
+            ? Ref.update(pendingRef, (pending) => ({
+                ...pending,
+                specDirty: true,
+              })).pipe(Effect.andThen(Queue.offer(signal, undefined)))
+            : Effect.void,
         ),
-      { bufferSize: 1, strategy: "sliding" },
-    );
-
-    yield* pipe(
-      specChanges,
-      Stream.debounce(Duration.millis(200)),
-      Stream.runForEach(() =>
-        Ref.update(pendingRef, (pending) => ({
-          ...pending,
-          specDirty: true,
-        })).pipe(Effect.andThen(Queue.offer(signal, undefined))),
-      ),
-    );
-  });
+      );
+    }),
+  );
 
 const formatBuildError = (
   error: esbuild.Message | undefined,
@@ -498,14 +526,10 @@ const formatBuildError = (
     Array.findFirstIndex(lines, (l) => pipe(l, String.trim, String.isNonEmpty)),
     Option.match({
       onNone: () => lines,
-      onSome: (idx) => Array.modify(lines, idx, () => redErrorText),
+      onSome: (index) => Array.modify(lines, index, () => redErrorText),
     }),
   );
-  return pipe(
-    replaced,
-    Array.map((l) => (pipe(l, String.trim, String.isNonEmpty) ? `  ${l}` : l)),
-    Array.join("\n"),
-  );
+  return pipe(replaced, Array.join("\n"));
 };
 
 const formatBuildErrors = (
@@ -519,15 +543,22 @@ const formatBuildErrors = (
     String.trimEnd,
   );
 
-export class SpecFileDoesNotExportSpecError extends Schema.TaggedError<SpecFileDoesNotExportSpecError>(
+export class SpecFileDoesNotExportSpecError extends Schema.TaggedError<SpecFileDoesNotExportSpecError>()(
   "SpecFileDoesNotExportSpecError",
-)("SpecFileDoesNotExportSpecError", {}) {}
+  {},
+) {}
 
-export class SpecImportFailedError extends Schema.TaggedError<SpecImportFailedError>(
+export class NodeSpecFileDoesNotExportSpecError extends Schema.TaggedError<NodeSpecFileDoesNotExportSpecError>()(
+  "NodeSpecFileDoesNotExportSpecError",
+  {},
+) {}
+
+export class SpecImportFailedError extends Schema.TaggedError<SpecImportFailedError>()(
   "SpecImportFailedError",
-)("SpecImportFailedError", {
-  error: Schema.Unknown,
-}) {}
+  {
+    error: Schema.Unknown,
+  },
+) {}
 
 const syncOptionalFile = (generate: typeof generateHttp, convexFile: string) =>
   pipe(
@@ -536,16 +567,9 @@ const syncOptionalFile = (generate: typeof generateHttp, convexFile: string) =>
       Option.match({
         onSome: ({ change, convexFilePath }) =>
           Match.value(change).pipe(
-            Match.when("Unchanged", () => Effect.succeed(Option.none())),
+            Match.when("Unchanged", () => Effect.void),
             Match.whenOr("Added", "Modified", (addedOrModified) =>
-              Effect.succeed(
-                Option.some(
-                  FileChange.OptionalFile({
-                    change: addedOrModified,
-                    filePath: convexFilePath,
-                  }),
-                ),
-              ),
+              logFileChangeIndented(addedOrModified, convexFilePath),
             ),
             Match.exhaustive,
           ),
@@ -558,15 +582,7 @@ const syncOptionalFile = (generate: typeof generateHttp, convexFile: string) =>
 
             if (yield* fs.exists(convexFilePath)) {
               yield* fs.remove(convexFilePath);
-
-              return Option.some(
-                FileChange.OptionalFile({
-                  change: "Removed",
-                  filePath: convexFilePath,
-                }),
-              );
-            } else {
-              return Option.none();
+              yield* logFileChangeIndented("Removed", convexFilePath);
             }
           }),
       }),
@@ -578,34 +594,45 @@ const optionalConfectFiles: ReadonlyRecord<string, keyof Pending> = {
   "app.ts": "appDirty",
   "crons.ts": "cronsDirty",
   "auth.ts": "authDirty",
+  "nodeSpec.ts": "specDirty",
+  "nodeImpl.ts": "nodeImplDirty",
 };
 
 const confectDirectoryWatcher = (
   signal: Queue.Queue<void>,
   pendingRef: Ref.Ref<Pending>,
+  specWatcherRestartQueue: Queue.Queue<void>,
 ) =>
   Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
     const confectDirectory = yield* ConfectDirectory.get;
 
     yield* pipe(
       fs.watch(confectDirectory),
-      Stream.runForEach((event) =>
-        pipe(
-          Option.fromNullable(optionalConfectFiles[event.path]),
-          Option.match({
-            onNone: () => Effect.void,
-            onSome: (pendingKey) =>
-              pipe(
-                pendingRef,
-                Ref.update((pending) => ({
-                  ...pending,
-                  [pendingKey]: true,
-                })),
-                Effect.andThen(Queue.offer(signal, undefined)),
-              ),
-          }),
-        ),
-      ),
+      Stream.runForEach((event) => {
+        const basename = path.basename(event.path);
+        const pendingKey = optionalConfectFiles[basename];
+
+        if (pendingKey !== undefined) {
+          return pipe(
+            pendingRef,
+            Ref.update((pending) => {
+              const next = { ...pending, [pendingKey]: true };
+              if (basename === "nodeImpl.ts") {
+                return { ...next, specDirty: true };
+              }
+              return next;
+            }),
+            Effect.andThen(Queue.offer(signal, undefined)),
+            Effect.andThen(
+              basename === "nodeSpec.ts"
+                ? Queue.offer(specWatcherRestartQueue, undefined)
+                : Effect.void,
+            ),
+          );
+        }
+        return Effect.void;
+      }),
     );
   });