@confect/cli 8.0.0 → 9.0.0-next.1

package/dist/confect/dev.mjs

@@ -1,26 +1,35 @@
-import { modulePath, toString } from "../GroupPath.mjs";
 import { ProjectRoot } from "../ProjectRoot.mjs";
-import { logFailure, logPending, logSuccess } from "../log.mjs";
+import { logFunctionAdded, logFunctionRemoved, logPending, logSuccess } from "../log.mjs";
+import { logCoalescedBuildErrors } from "../BuildError.mjs";
+import { catchAndLog } from "../CodegenError.mjs";
 import { ConvexDirectory } from "../ConvexDirectory.mjs";
 import { ConfectDirectory } from "../ConfectDirectory.mjs";
-import { diff, make } from "../FunctionPaths.mjs";
-import { EXTERNAL_PACKAGES, bundleAndImport, generateAuthConfig, generateCrons, generateHttp, removeGroups, writeGroups } from "../utils.mjs";
-import { codegenHandler, generateNodeApi, generateNodeRegisteredFunctions } from "./codegen.mjs";
-import { Array, Console, Deferred, Duration, Effect, Equal, HashSet, Match, Option, Queue, Ref, Schema, Stream, String, pipe } from "effect";
+import { FunctionPaths, diff } from "../FunctionPaths.mjs";
+import { EXTERNAL_PACKAGES, absoluteExternalsPlugin } from "../Bundler.mjs";
+import { generateAuthConfig, generateCrons, generateHttp } from "../utils.mjs";
+import { discoverLeafImplFiles, isLeafImplPath, isLeafSpecPath } from "../LeafModule.mjs";
+import { codegenHandler, loadPreviousFunctionPaths } from "./codegen.mjs";
+import { Array, Chunk, Clock, Console, Duration, Effect, Equal, ExecutionStrategy, Exit, HashSet, Match, Option, Order, Queue, Ref, Scope, Stream, String, pipe } from "effect";
 import { Command } from "@effect/cli";
-import { Spec } from "@confect/core";
 import { FileSystem, Path } from "@effect/platform";
 import { Ansi, AnsiDoc } from "@effect/printer-ansi";
 import * as esbuild from "esbuild";
 
 //#region src/confect/dev.ts
+const GENERATED_SPEC_PATH = "_generated/spec.ts";
+const GENERATED_NODE_SPEC_PATH = "_generated/nodeSpec.ts";
+const COALESCE_QUIESCENCE = Duration.millis(300);
+const COALESCE_MAX_WAIT = Duration.seconds(5);
+const ECHO_COOLDOWN = Duration.millis(500);
+const emptyFunctionPaths = FunctionPaths.make(HashSet.empty());
 const pendingInit = {
 	specDirty: false,
-	nodeImplDirty: false,
 	httpDirty: false,
 	cronsDirty: false,
 	authDirty: false
 };
+const isPendingDirty = (p) => p.specDirty || p.httpDirty || p.cronsDirty || p.authDirty;
+const emptyWatcherErrors = /* @__PURE__ */ new Map();
 const changeChar = (change) => Match.value(change).pipe(Match.when("Added", () => ({
 	char: "+",
 	color: Ansi.green
@@ -37,182 +46,255 @@ const logFileChangeIndented = (change, fullPath) => Effect.gen(function* () {
 	const { char, color } = changeChar(change);
 	yield* Console.log(pipe(AnsiDoc.char(char), AnsiDoc.annotate(color), AnsiDoc.catWithSpace(AnsiDoc.hcat([pipe(AnsiDoc.text(prefix), AnsiDoc.annotate(Ansi.blackBright)), pipe(AnsiDoc.text(suffix), AnsiDoc.annotate(color))])), AnsiDoc.render({ style: "pretty" })));
 });
-const logFunctionAddedIndented = (functionPath) => Console.log(pipe(AnsiDoc.text("  "), AnsiDoc.cat(pipe(AnsiDoc.char("+"), AnsiDoc.annotate(Ansi.green))), AnsiDoc.catWithSpace(AnsiDoc.hcat([pipe(AnsiDoc.text(toString(functionPath.groupPath) + "."), AnsiDoc.annotate(Ansi.blackBright)), pipe(AnsiDoc.text(functionPath.name), AnsiDoc.annotate(Ansi.green))])), AnsiDoc.render({ style: "pretty" })));
-const logFunctionRemovedIndented = (functionPath) => Console.log(pipe(AnsiDoc.text("  "), AnsiDoc.cat(pipe(AnsiDoc.char("-"), AnsiDoc.annotate(Ansi.red))), AnsiDoc.catWithSpace(AnsiDoc.hcat([pipe(AnsiDoc.text(toString(functionPath.groupPath) + "."), AnsiDoc.annotate(Ansi.blackBright)), pipe(AnsiDoc.text(functionPath.name), AnsiDoc.annotate(Ansi.red))])), AnsiDoc.render({ style: "pretty" })));
+const logFunctionPathDiff = (previous, current) => Effect.gen(function* () {
+	const { functionsAdded, functionsRemoved, groupsRemoved, groupsAdded, groupsChanged } = diff(previous, current);
+	const logForGroups = (groupPaths, fnPaths, logFn) => Effect.forEach(groupPaths, (gp) => Effect.forEach(Array.fromIterable(HashSet.filter(fnPaths, (fp) => Equal.equals(fp.groupPath, gp))), logFn));
+	yield* logForGroups(groupsRemoved, functionsRemoved, logFunctionRemoved);
+	yield* logForGroups(groupsAdded, functionsAdded, logFunctionAdded);
+	yield* Effect.forEach(groupsChanged, (gp) => Effect.gen(function* () {
+		yield* Effect.forEach(Array.fromIterable(HashSet.filter(functionsAdded, (fp) => Equal.equals(fp.groupPath, gp))), logFunctionAdded);
+		yield* Effect.forEach(Array.fromIterable(HashSet.filter(functionsRemoved, (fp) => Equal.equals(fp.groupPath, gp))), logFunctionRemoved);
+	}));
+});
 const dev = Command.make("dev", {}, () => Effect.gen(function* () {
 	yield* logPending("Performing initial sync…");
-	const initialFunctionPaths = yield* codegenHandler;
+	const previousFunctionPaths = yield* loadPreviousFunctionPaths;
+	const initialResult = yield* codegenHandler.pipe(Effect.tap(({ functionPaths }) => logFunctionPathDiff(previousFunctionPaths, functionPaths)), Effect.tap(() => logSuccess("Generated files are up-to-date")), catchAndLog);
+	const initialFunctionPaths = Option.match(initialResult, {
+		onNone: () => emptyFunctionPaths,
+		onSome: ({ functionPaths }) => functionPaths
+	});
 	const pendingRef = yield* Ref.make(pendingInit);
 	const signal = yield* Queue.sliding(1);
-	const specWatcherRestartQueue = yield* Queue.sliding(1);
+	const restartQueue = yield* Queue.sliding(1);
+	const watcherErrorsRef = yield* Ref.make(emptyWatcherErrors);
 	yield* Effect.all([
-		specFileWatcher(signal, pendingRef, specWatcherRestartQueue),
-		confectDirectoryWatcher(signal, pendingRef, specWatcherRestartQueue),
-		syncLoop(signal, pendingRef, initialFunctionPaths)
+		Effect.scoped(entryPointsWatcher(signal, pendingRef, restartQueue, watcherErrorsRef)),
+		confectStructureWatcher(signal, pendingRef, restartQueue),
+		syncLoop(signal, pendingRef, initialFunctionPaths, watcherErrorsRef)
 	], { concurrency: "unbounded" });
 })).pipe(Command.withDescription("Start the Confect development server"));
-const syncLoop = (signal, pendingRef, initialFunctionPaths) => Effect.gen(function* () {
+const esbuildMessageKey = (m) => `${m.location?.file ?? ""}:${m.location?.line ?? ""}:${m.location?.column ?? ""}:${m.text}`;
+const allMessages = (errors) => pipe(Array.fromIterable(errors.values()), Array.flatten);
+const dedupeWatcherErrors = (errors) => pipe(allMessages(errors), Array.dedupeWith((messageA, messageB) => esbuildMessageKey(messageA) === esbuildMessageKey(messageB)));
+const watcherErrorsSignature = (errors) => pipe(allMessages(errors), Array.map(esbuildMessageKey), Array.dedupe, Array.sort(Order.string), Array.join("\n"));
+/**
+* Log any watcher errors that haven't already been logged at their
+* current signature. Suppresses the per-watcher fanout that happens
+* when one root cause (e.g. a missing import) breaks every entry
+* point's build at the same source location.
+*/
+const logChangedWatcherErrors = (watcherErrorsRef, lastLoggedSignatureRef) => Effect.gen(function* () {
+	const errors = yield* Ref.get(watcherErrorsRef);
+	const signature = watcherErrorsSignature(errors);
+	if (signature === (yield* Ref.get(lastLoggedSignatureRef))) return;
+	yield* Ref.set(lastLoggedSignatureRef, signature);
+	if (errors.size === 0) return;
+	yield* logCoalescedBuildErrors(dedupeWatcherErrors(errors));
+});
+/**
+* Block until the signal queue has been quiet for `quiescence`. esbuild
+* watchers' `onEnd` events for a single user edit can be spread across
+* hundreds of milliseconds, so a fixed window misses late arrivals.
+* Bounded by `maxWait` so pathological signal floods can't pin the
+* loop forever.
+*/
+const drainUntilQuiescent = (signal, quiescence, maxWait) => Effect.gen(function* () {
+	const start = yield* Clock.currentTimeMillis;
+	const maxMillis = Duration.toMillis(maxWait);
+	yield* Effect.iterate(true, {
+		while: (keepGoing) => keepGoing,
+		body: () => Effect.gen(function* () {
+			yield* Effect.sleep(quiescence);
+			const drained = yield* Queue.takeAll(signal);
+			if (Chunk.isEmpty(drained)) return false;
+			return (yield* Clock.currentTimeMillis) - start < maxMillis;
+		})
+	});
+});
+const syncLoop = (signal, pendingRef, initialFunctionPaths, watcherErrorsRef) => Effect.gen(function* () {
 	const functionPathsRef = yield* Ref.make(initialFunctionPaths);
-	const initialSyncDone = yield* Deferred.make();
+	const lastLoggedErrorsRef = yield* Ref.make("");
 	return yield* Effect.forever(Effect.gen(function* () {
-		yield* Effect.logDebug("Running sync loop...");
+		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, void 0);
+		yield* drainUntilQuiescent(signal, COALESCE_QUIESCENCE, COALESCE_MAX_WAIT);
+		yield* logChangedWatcherErrors(watcherErrorsRef, lastLoggedErrorsRef);
 		const pending = yield* Ref.getAndSet(pendingRef, pendingInit);
-		if (pending.specDirty || pending.nodeImplDirty) {
-			yield* generateNodeApi;
-			yield* generateNodeRegisteredFunctions;
+		if (!isPendingDirty(pending)) return;
+		yield* logPending("Dependencies may have changed, reloading…");
+		if (pending.specDirty) {
+			const current = yield* codegenHandler.pipe(Effect.tap(({ functionPaths: nextFunctionPaths }) => Effect.gen(function* () {
+				yield* logFunctionPathDiff(yield* Ref.get(functionPathsRef), nextFunctionPaths);
+				yield* Ref.set(functionPathsRef, nextFunctionPaths);
+			})), catchAndLog);
+			if (Option.isNone(current)) return;
+			if (current.value.anyWritesHappened) yield* Effect.sleep(ECHO_COOLDOWN);
+			yield* drainUntilQuiescent(signal, COALESCE_QUIESCENCE, COALESCE_MAX_WAIT);
+			yield* Ref.set(pendingRef, pendingInit);
 		}
-		const specResult = yield* Effect.if(pending.specDirty, {
-			onTrue: () => loadSpec.pipe(Effect.andThen(Effect.fn(function* (spec) {
-				yield* Effect.logDebug("Spec loaded");
-				const previous = yield* Ref.get(functionPathsRef);
-				const path = yield* Path.Path;
-				const convexDirectory = yield* ConvexDirectory.get;
-				const current = make(spec);
-				const { functionsAdded, functionsRemoved, groupsRemoved, groupsAdded, groupsChanged } = diff(previous, current);
-				yield* removeGroups(groupsRemoved);
-				yield* Effect.forEach(groupsRemoved, (gp) => Effect.gen(function* () {
-					const relativeModulePath = yield* modulePath(gp);
-					yield* logFileChangeIndented("Removed", path.join(convexDirectory, relativeModulePath));
-					yield* Effect.forEach(Array.fromIterable(HashSet.filter(functionsRemoved, (fp) => Equal.equals(fp.groupPath, gp))), logFunctionRemovedIndented);
-				}));
-				yield* writeGroups(spec, groupsAdded);
-				yield* Effect.forEach(groupsAdded, (gp) => Effect.gen(function* () {
-					const relativeModulePath = yield* modulePath(gp);
-					yield* logFileChangeIndented("Added", path.join(convexDirectory, relativeModulePath));
-					yield* Effect.forEach(Array.fromIterable(HashSet.filter(functionsAdded, (fp) => Equal.equals(fp.groupPath, gp))), logFunctionAddedIndented);
-				}));
-				yield* writeGroups(spec, groupsChanged);
-				yield* Effect.forEach(groupsChanged, (gp) => Effect.gen(function* () {
-					const relativeModulePath = yield* modulePath(gp);
-					yield* logFileChangeIndented("Modified", path.join(convexDirectory, relativeModulePath));
-					yield* Effect.forEach(Array.fromIterable(HashSet.filter(functionsAdded, (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(void 0);
-			})), Effect.catchTag("SpecImportFailedError", () => logFailure("Spec import failed").pipe(Effect.as(Option.none()))), Effect.catchTag("SpecFileDoesNotExportSpecError", () => 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(void 0))
-		});
 		const dirtyOptionalFiles = [
 			...pending.httpDirty ? [syncOptionalFile(generateHttp, "http.ts")] : [],
 			...pending.cronsDirty ? [syncOptionalFile(generateCrons, "crons.ts")] : [],
 			...pending.authDirty ? [syncOptionalFile(generateAuthConfig, "auth.config.ts")] : []
 		];
 		yield* Array.isNonEmptyReadonlyArray(dirtyOptionalFiles) ? Effect.all(dirtyOptionalFiles, { concurrency: "unbounded" }) : Effect.void;
-		yield* Option.match(specResult, {
-			onSome: () => logSuccess("Generated files are up-to-date"),
-			onNone: () => Effect.void
-		});
+		yield* logSuccess("Generated files are up-to-date");
 	}));
 });
-const loadSpec = Effect.gen(function* () {
+/**
+* Every file whose import graph codegen should react to. Each one becomes
+* its own scoped esbuild watcher; the union of their watches gives us
+* dependency-aware tracking of anything reachable from `confect/`,
+* including files outside `confect/`.
+*/
+const discoverEntryPoints = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
+	const projectRoot = yield* ProjectRoot.get;
 	const confectDirectory = yield* ConfectDirectory.get;
-	const spec = (yield* bundleAndImport(yield* getSpecPath).pipe(Effect.mapError((error) => new SpecImportFailedError({ error })))).default;
-	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;
-	return Option.match(nodeSpecOption, {
-		onNone: () => spec,
-		onSome: (nodeSpec) => nodeImplExists ? Spec.merge(spec, nodeSpec) : spec
+	const tryEntry = (relativePath, pendingKey) => Effect.gen(function* () {
+		const absolutePath = path.join(confectDirectory, relativePath);
+		if (!(yield* fs.exists(absolutePath))) return Option.none();
+		return Option.some({
+			absolutePath,
+			displayPath: path.relative(projectRoot, absolutePath),
+			pendingKey
+		});
 	});
+	const fixedEntryOptions = yield* Effect.all([
+		tryEntry(GENERATED_SPEC_PATH, "specDirty"),
+		tryEntry(GENERATED_NODE_SPEC_PATH, "specDirty"),
+		tryEntry("schema.ts", "specDirty"),
+		tryEntry("http.ts", "httpDirty"),
+		tryEntry("crons.ts", "cronsDirty"),
+		tryEntry("auth.ts", "authDirty")
+	]);
+	const implRelativePaths = yield* discoverLeafImplFiles;
+	const implEntryOptions = yield* Effect.forEach(implRelativePaths, (relativePath) => tryEntry(relativePath, "specDirty"));
+	return Array.getSomes([...fixedEntryOptions, ...implEntryOptions]);
 });
-const getSpecPath = Effect.gen(function* () {
-	const path = yield* Path.Path;
-	const confectDirectory = yield* ConfectDirectory.get;
-	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 nodeSpecPath = yield* getNodeSpecPath;
-	if (!(yield* fs.exists(nodeSpecPath))) return Option.none();
-	const nodeSpec = (yield* bundleAndImport(nodeSpecPath).pipe(Effect.mapError((error) => new SpecImportFailedError({ error })))).default;
-	if (!Spec.isNodeSpec(nodeSpec)) return yield* new NodeSpecFileDoesNotExportSpecError();
-	return Option.some(nodeSpec);
-});
-const esbuildOptions = (entryPoint) => ({
-	entryPoints: [entryPoint],
-	bundle: true,
-	write: false,
-	metafile: true,
-	platform: "node",
-	format: "esm",
-	logLevel: "silent",
-	external: EXTERNAL_PACKAGES,
-	plugins: [{
-		name: "notify-rebuild",
-		setup(build) {
-			build.onEnd((result) => {
-				if (result.errors.length === 0) build._emit?.();
-				else Effect.runPromise(Effect.gen(function* () {
-					const formattedMessages = yield* Effect.promise(() => esbuild.formatMessages(result.errors, {
-						kind: "error",
-						color: true,
-						terminalWidth: 80
+const esbuildOptions = (entry, signal, pendingRef, watcherErrorsRef) => {
+	const initialBuildSeenRef = Ref.unsafeMake(false);
+	return {
+		entryPoints: [entry.absolutePath],
+		bundle: true,
+		write: false,
+		metafile: true,
+		platform: "node",
+		format: "esm",
+		logLevel: "silent",
+		external: EXTERNAL_PACKAGES,
+		plugins: [absoluteExternalsPlugin, {
+			name: "notify-rebuild",
+			setup(build) {
+				build.onEnd((result) => {
+					Effect.runPromise(Effect.gen(function* () {
+						const isInitial = !(yield* Ref.getAndSet(initialBuildSeenRef, true));
+						yield* Ref.update(watcherErrorsRef, (current) => {
+							const next = new Map(current);
+							if (result.errors.length > 0) next.set(entry.absolutePath, result.errors);
+							else next.delete(entry.absolutePath);
+							return next;
+						});
+						if (isInitial && result.errors.length === 0) return;
+						yield* Ref.update(pendingRef, (p) => ({
+							...p,
+							[entry.pendingKey]: true
+						}));
+						yield* Queue.offer(signal, void 0);
 					}));
-					const output = formatBuildErrors(result.errors, formattedMessages);
-					yield* Console.error("\n" + output + "\n");
-					yield* logFailure("Build errors found");
-				}));
-			});
-		}
-	}]
-});
-const createSpecWatcher = (entryPoint) => Stream.asyncPush((emit) => Effect.acquireRelease(Effect.promise(async () => {
-	const opts = esbuildOptions(entryPoint);
-	const plugin = opts.plugins[0];
-	const originalSetup = plugin.setup;
-	plugin.setup = (build) => {
-		build._emit = () => emit.single();
-		return originalSetup(build);
+				});
+			}
+		}]
 	};
-	const ctx = await esbuild.context({
-		...opts,
-		plugins: [plugin]
-	});
+};
+const createEntryPointWatcher = (entry, signal, pendingRef, watcherErrorsRef) => Effect.acquireRelease(Effect.promise(async () => {
+	const ctx = await esbuild.context(esbuildOptions(entry, signal, pendingRef, watcherErrorsRef));
 	await ctx.watch();
 	return ctx;
-}), (ctx) => Effect.promise(() => ctx.dispose()).pipe(Effect.tap(() => Effect.logDebug("esbuild watcher disposed")))), {
-	bufferSize: 1,
-	strategy: "sliding"
+}), (ctx) => Effect.gen(function* () {
+	yield* Effect.promise(() => ctx.dispose());
+	yield* Ref.update(watcherErrorsRef, (current) => {
+		if (!current.has(entry.absolutePath)) return current;
+		const next = new Map(current);
+		next.delete(entry.absolutePath);
+		return next;
+	});
+	yield* Effect.logDebug(`esbuild watcher disposed: ${entry.displayPath}`);
+}));
+/**
+* Holds one scoped esbuild watcher per entry point and reconciles the set
+* whenever something offers to `restartQueue`. Adding or removing an entry
+* point only spawns/disposes the affected watcher; unchanged entries keep
+* their existing context, so a structural change doesn't churn watchers
+* for unrelated files.
+*/
+const entryPointsWatcher = (signal, pendingRef, restartQueue, watcherErrorsRef) => Effect.gen(function* () {
+	const parentScope = yield* Effect.scope;
+	const scopesRef = yield* Ref.make(/* @__PURE__ */ new Map());
+	const sync = Effect.gen(function* () {
+		const desired = yield* discoverEntryPoints;
+		const desiredByPath = new Map(desired.map((entryPoint) => [entryPoint.absolutePath, entryPoint]));
+		const current = yield* Ref.get(scopesRef);
+		yield* Effect.forEach(Array.fromIterable(current), ([absolutePath, childScope]) => desiredByPath.has(absolutePath) ? Effect.void : Scope.close(childScope, Exit.void).pipe(Effect.andThen(Ref.update(scopesRef, (scopes) => {
+			const updated = new Map(scopes);
+			updated.delete(absolutePath);
+			return updated;
+		}))));
+		yield* Effect.forEach(desired, (entry) => Effect.gen(function* () {
+			if ((yield* Ref.get(scopesRef)).has(entry.absolutePath)) return;
+			const childScope = yield* Scope.fork(parentScope, ExecutionStrategy.sequential);
+			yield* createEntryPointWatcher(entry, signal, pendingRef, watcherErrorsRef).pipe(Scope.extend(childScope));
+			yield* Ref.update(scopesRef, (scopes) => {
+				const updated = new Map(scopes);
+				updated.set(entry.absolutePath, childScope);
+				return updated;
+			});
+		}));
+	});
+	yield* sync;
+	return yield* Effect.forever(Queue.take(restartQueue).pipe(Effect.andThen(sync)));
 });
-const specFileWatcher = (signal, pendingRef, specWatcherRestartQueue) => Effect.forever(Effect.gen(function* () {
+/**
+* Single recursive `fs.watch` on `confect/`. Flips the matching dirty flag
+* for any change to an entry-point-shaped file (so codegen runs without
+* waiting on a newly spawned esbuild watcher), and offers to
+* `restartQueue` when an entry point is created or removed so the watcher
+* manager picks up the new set.
+*/
+const confectStructureWatcher = (signal, pendingRef, restartQueue) => 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(() => "change"));
-	const restartStream = pipe(Stream.fromQueue(specWatcherRestartQueue), Stream.map(() => "restart"));
-	yield* pipe(Stream.merge(specChanges, restartStream), Stream.debounce(Duration.millis(200)), Stream.takeUntil((event) => event === "restart"), Stream.runForEach((event) => event === "change" ? Ref.update(pendingRef, (pending) => ({
-		...pending,
-		specDirty: true
-	})).pipe(Effect.andThen(Queue.offer(signal, void 0))) : Effect.void));
-}));
-const formatBuildError = (error, formattedMessage) => {
-	const lines = String.split(formattedMessage, "\n");
-	const redErrorText = pipe(AnsiDoc.text(error?.text ?? ""), AnsiDoc.annotate(Ansi.red), AnsiDoc.render({ style: "pretty" }));
-	return pipe(pipe(Array.findFirstIndex(lines, (l) => pipe(l, String.trim, String.isNonEmpty)), Option.match({
-		onNone: () => lines,
-		onSome: (index) => Array.modify(lines, index, () => redErrorText)
-	})), Array.join("\n"));
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	yield* pipe(fs.watch(confectDirectory, { recursive: true }), Stream.debounce(Duration.millis(200)), Stream.runForEach((event) => handleConfectChange({
+		relativePath: path.relative(confectDirectory, event.path),
+		eventTag: event._tag,
+		signal,
+		pendingRef,
+		restartQueue
+	})));
+});
+const TOP_LEVEL_OPTIONAL_KEYS = new Map([
+	["http.ts", "httpDirty"],
+	["crons.ts", "cronsDirty"],
+	["auth.ts", "authDirty"]
+]);
+const flipDirtyAndSignal = (pendingRef, signal, key, restartQueue, restart) => pipe(Ref.update(pendingRef, (p) => ({
+	...p,
+	[key]: true
+})), Effect.andThen(Queue.offer(signal, void 0)), Effect.andThen(restart ? Queue.offer(restartQueue, void 0) : Effect.void));
+const handleConfectChange = ({ relativePath, eventTag, signal, pendingRef, restartQueue }) => {
+	if (relativePath.split(/[/\\]/).includes("_generated")) return Effect.void;
+	if (!relativePath.endsWith(".ts")) return Effect.void;
+	const isLifecycleChange = eventTag !== "Update";
+	const topLevelKey = TOP_LEVEL_OPTIONAL_KEYS.get(relativePath);
+	if (topLevelKey !== void 0) return flipDirtyAndSignal(pendingRef, signal, topLevelKey, restartQueue, isLifecycleChange);
+	if (relativePath === "schema.ts") return flipDirtyAndSignal(pendingRef, signal, "specDirty", restartQueue, isLifecycleChange);
+	if (isLeafSpecPath(relativePath) || isLeafImplPath(relativePath)) return flipDirtyAndSignal(pendingRef, signal, "specDirty", restartQueue, isLifecycleChange);
+	if (eventTag === "Create") return flipDirtyAndSignal(pendingRef, signal, "specDirty", restartQueue, false);
+	return Effect.void;
 };
-const formatBuildErrors = (errors, formattedMessages) => pipe(formattedMessages, Array.map((message, i) => formatBuildError(errors[i], message)), Array.join(""), String.trimEnd);
-var SpecFileDoesNotExportSpecError = class extends Schema.TaggedError()("SpecFileDoesNotExportSpecError", {}) {};
-var NodeSpecFileDoesNotExportSpecError = class extends Schema.TaggedError()("NodeSpecFileDoesNotExportSpecError", {}) {};
-var SpecImportFailedError = class extends Schema.TaggedError()("SpecImportFailedError", { error: Schema.Unknown }) {};
 const syncOptionalFile = (generate, convexFile) => pipe(generate, Effect.andThen(Option.match({
 	onSome: ({ change, convexFilePath }) => Match.value(change).pipe(Match.when("Unchanged", () => Effect.void), Match.whenOr("Added", "Modified", (addedOrModified) => logFileChangeIndented(addedOrModified, convexFilePath)), Match.exhaustive),
 	onNone: () => Effect.gen(function* () {
@@ -226,34 +308,6 @@ const syncOptionalFile = (generate, convexFile) => pipe(generate, Effect.andThen
 		}
 	})
 })));
-const optionalConfectFiles = {
-	"http.ts": "httpDirty",
-	"crons.ts": "cronsDirty",
-	"auth.ts": "authDirty",
-	"nodeSpec.ts": "specDirty",
-	"nodeImpl.ts": "nodeImplDirty"
-};
-const confectDirectoryWatcher = (signal, pendingRef, specWatcherRestartQueue) => 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) => {
-		const basename = path.basename(event.path);
-		const pendingKey = optionalConfectFiles[basename];
-		if (pendingKey !== void 0) 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, void 0)), Effect.andThen(basename === "nodeSpec.ts" ? Queue.offer(specWatcherRestartQueue, void 0) : Effect.void));
-		return Effect.void;
-	}));
-});
 
 //#endregion
 export { dev };