@smithers-orchestrator/engine 0.16.0

package/src/events.js

@@ -0,0 +1,237 @@
+import { EventEmitter } from "node:events";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Effect } from "effect";
+import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
+import { trackEvent } from "@smithers-orchestrator/observability/metrics";
+import { correlationContextToLogAnnotations, getCurrentCorrelationContext, mergeCorrelationContext, withCurrentCorrelationContext, } from "@smithers-orchestrator/observability/correlation";
+/** @typedef {import("@smithers-orchestrator/observability/correlation").CorrelationContext} CorrelationContext */
+
+/**
+ * @typedef {SmithersEvent & { correlation?: CorrelationContext; }} CorrelatedSmithersEvent
+ */
+/** @typedef {import("@smithers-orchestrator/observability/SmithersEvent").SmithersEvent} SmithersEvent */
+/** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase<Record<string, unknown>>} _BunSQLiteDatabase */
+
+export class EventBus extends EventEmitter {
+    seq = 0;
+    logDir;
+    db;
+    persistTail = Promise.resolve();
+    persistError = null;
+    /**
+   * @param {{ db?: BunSQLiteDatabase; logDir?: string; startSeq?: number }} opts
+   */
+    constructor(opts) {
+        super();
+        this.db = opts.db;
+        this.logDir = opts.logDir;
+        this.seq = opts.startSeq ?? 0;
+    }
+    /**
+   * @param {SmithersEvent} event
+   * @returns {Effect.Effect<void, unknown>}
+   */
+    emitEvent(event) {
+        const correlatedEvent = this.attachCorrelation(event);
+        const self = this;
+        return withCurrentCorrelationContext(Effect.gen(function* () {
+            yield* self.emitAndTrack(correlatedEvent);
+            if (self.db) {
+                yield* self.persistDb(correlatedEvent);
+            }
+        }).pipe(Effect.annotateLogs(this.eventLogAnnotations(correlatedEvent)), Effect.withLogSpan(`event:${correlatedEvent.type}`)));
+    }
+    /**
+   * @param {SmithersEvent} event
+   * @returns {Effect.Effect<void, unknown>}
+   */
+    emitEventWithPersist(event) {
+        const correlatedEvent = this.attachCorrelation(event);
+        const self = this;
+        return withCurrentCorrelationContext(Effect.gen(function* () {
+            yield* self.emitAndTrack(correlatedEvent);
+            yield* self.persist(correlatedEvent);
+        }).pipe(Effect.annotateLogs(this.eventLogAnnotations(correlatedEvent)), Effect.withLogSpan(`event:${correlatedEvent.type}:persist`)));
+    }
+    /**
+   * @param {SmithersEvent} event
+   * @returns {Promise<void>}
+   */
+    emitEventQueued(event) {
+        const correlatedEvent = this.attachCorrelation(event);
+        this.emit("event", correlatedEvent);
+        return Effect.runPromise(withCurrentCorrelationContext(trackEvent(correlatedEvent).pipe(Effect.andThen(this.enqueuePersist(correlatedEvent)))));
+    }
+    /**
+   * @returns {Effect.Effect<void, unknown>}
+   */
+    flush() {
+        return withCurrentCorrelationContext(Effect.tryPromise({
+            try: async () => {
+                await this.persistTail;
+                if (this.persistError) {
+                    const err = this.persistError;
+                    this.persistError = null;
+                    throw err;
+                }
+            },
+            catch: (cause) => toSmithersError(cause, "flush queued events"),
+        }).pipe(Effect.withLogSpan("event:flush")));
+    }
+    /**
+   * @param {CorrelatedSmithersEvent} event
+   * @returns {Effect.Effect<void, unknown>}
+   */
+    persist(event) {
+        const self = this;
+        return withCurrentCorrelationContext(Effect.gen(function* () {
+            yield* self.persistDb(event);
+            const persistedLog = yield* Effect.either(self.persistLog(event));
+            if (persistedLog._tag === "Left") {
+                yield* Effect.logWarning(`[smithers] failed to append event log: ${persistedLog.left instanceof Error ? persistedLog.left.message : String(persistedLog.left)}`);
+            }
+        }).pipe(Effect.annotateLogs(this.eventLogAnnotations(event)), Effect.withLogSpan("event:persist")));
+    }
+    /**
+   * @param {CorrelatedSmithersEvent} event
+   * @returns {Effect.Effect<void, unknown>}
+   */
+    emitAndTrack(event) {
+        const self = this;
+        return Effect.gen(function* () {
+            yield* Effect.sync(() => self.emit("event", event));
+            yield* trackEvent(event);
+        });
+    }
+    /**
+   * @param {CorrelatedSmithersEvent} event
+   * @returns {Effect.Effect<void, unknown>}
+   */
+    enqueuePersist(event) {
+        const task = this.persistTail.then(() => Effect.runPromise(this.persist(event)));
+        this.persistTail = task.catch((error) => {
+            this.persistError = error;
+        });
+        return Effect.tryPromise({
+            try: () => task,
+            catch: (cause) => toSmithersError(cause, "enqueue event persistence"),
+        });
+    }
+    /**
+   * @param {CorrelatedSmithersEvent} event
+   * @returns {Effect.Effect<void, unknown>}
+   */
+    persistDb(event) {
+        if (!this.db)
+            return Effect.void;
+        const payloadJson = JSON.stringify(event);
+        const nextSeqRow = {
+            runId: event.runId,
+            timestampMs: event.timestampMs,
+            type: event.type,
+            payloadJson,
+        };
+        const eventRow = {
+            ...nextSeqRow,
+            seq: this.seq++,
+        };
+        if (typeof this.db.insertEventWithNextSeqEffect === "function") {
+            return this.callDbPersistence(`insert event ${event.type}`, this.db.insertEventWithNextSeqEffect, nextSeqRow);
+        }
+        if (typeof this.db.insertEventWithNextSeq === "function") {
+            return this.callDbPersistence(`insert event ${event.type}`, this.db.insertEventWithNextSeq, nextSeqRow);
+        }
+        if (typeof this.db.insertEventEffect === "function") {
+            return this.callDbPersistence(`insert event ${event.type}`, this.db.insertEventEffect, eventRow);
+        }
+        if (typeof this.db.insertEvent === "function") {
+            return this.callDbPersistence(`insert event ${event.type}`, this.db.insertEvent, eventRow);
+        }
+        return Effect.void;
+    }
+    /**
+   * @param {string} label
+   * @param {(row: any) => unknown} method
+   * @param {any} row
+   * @returns {Effect.Effect<void, unknown>}
+   */
+    callDbPersistence(label, method, row) {
+        const db = this.db;
+        return Effect.try({
+            try: () => method.call(db, row),
+            catch: (cause) => toSmithersError(cause, label),
+        }).pipe(Effect.flatMap((result) => {
+            if (Effect.isEffect(result)) {
+                return result;
+            }
+            if (result &&
+                typeof result === "object" &&
+                typeof result.then === "function") {
+                return Effect.tryPromise({
+                    try: () => result,
+                    catch: (cause) => toSmithersError(cause, label),
+                });
+            }
+            return Effect.void;
+        }), Effect.asVoid);
+    }
+    /**
+   * @param {CorrelatedSmithersEvent} event
+   * @returns {Effect.Effect<void, unknown>}
+   */
+    persistLog(event) {
+        if (!this.logDir)
+            return Effect.void;
+        const dir = this.logDir;
+        return Effect.tryPromise({
+            try: async () => {
+                await mkdir(dir, { recursive: true });
+                const file = join(dir, "stream.ndjson");
+                const line = JSON.stringify(event) + "\n";
+                let prefix = "";
+                try {
+                    prefix = await readFile(file, "utf8");
+                }
+                catch (error) {
+                    if (!error ||
+                        typeof error !== "object" ||
+                        error.code !== "ENOENT") {
+                        throw error;
+                    }
+                }
+                await writeFile(file, prefix + line);
+            },
+            catch: (cause) => toSmithersError(cause, "append event log"),
+        });
+    }
+    /**
+   * @param {SmithersEvent} event
+   * @returns {CorrelatedSmithersEvent}
+   */
+    attachCorrelation(event) {
+        const correlation = mergeCorrelationContext(getCurrentCorrelationContext(), {
+            runId: event.runId,
+            nodeId: "nodeId" in event && typeof event.nodeId === "string"
+                ? event.nodeId
+                : undefined,
+            iteration: "iteration" in event && typeof event.iteration === "number"
+                ? event.iteration
+                : undefined,
+            attempt: "attempt" in event && typeof event.attempt === "number"
+                ? event.attempt
+                : undefined,
+        });
+        return correlation ? { ...event, correlation } : event;
+    }
+    /**
+   * @param {CorrelatedSmithersEvent} event
+   */
+    eventLogAnnotations(event) {
+        return {
+            ...correlationContextToLogAnnotations(event.correlation),
+            runId: event.runId,
+            eventType: event.type,
+        };
+    }
+}

package/src/external/json-schema-to-zod.js

@@ -0,0 +1,214 @@
+/**
+ * Convert JSON Schema to Zod schemas.
+ *
+ * Handles standard JSON Schema patterns:
+ * - $defs for nested model references
+ * - anyOf + null for Optional fields → .nullable()
+ */
+import { z } from "zod";
+/**
+ * @typedef {Record<string, any>} JsonSchema
+ */
+
+/**
+ * Convert a JSON Schema to a Zod object schema.
+ *
+ * @param {JsonSchema} rootSchema
+ * @returns {z.ZodObject<any>}
+ */
+export function jsonSchemaToZod(rootSchema) {
+    const result = convertNode(rootSchema, rootSchema, new Set());
+    if (result instanceof z.ZodObject)
+        return result;
+    return z.object({}).catchall(z.unknown());
+}
+/**
+ * @param {JsonSchema | undefined} node
+ * @param {JsonSchema} root
+ * @param {Set<string>} visited
+ * @returns {z.ZodType}
+ */
+function convertNode(node, root, visited) {
+    if (!node)
+        return z.any();
+    if (node.$ref && typeof node.$ref === "string") {
+        const ref = node.$ref;
+        if (visited.has(ref)) {
+            return z.any().describe(`Circular reference: ${ref}`);
+        }
+        visited.add(ref);
+        const resolved = resolveJsonPointer(root, ref);
+        const result = convertNode(resolved, root, visited);
+        visited.delete(ref);
+        return result;
+    }
+    if (node.allOf && Array.isArray(node.allOf) && node.allOf.length > 0) {
+        const schemas = node.allOf.map((sub) => convertNode(sub, root, visited));
+        if (schemas.length === 1)
+            return maybeDescribe(schemas[0], node);
+        let result = schemas[0];
+        for (let i = 1; i < schemas.length; i++) {
+            result = z.intersection(result, schemas[i]);
+        }
+        return maybeDescribe(result, node);
+    }
+    if (node.anyOf && Array.isArray(node.anyOf) && node.anyOf.length > 0) {
+        return buildAnyOf(node.anyOf, root, visited, node);
+    }
+    if (node.oneOf && Array.isArray(node.oneOf) && node.oneOf.length > 0) {
+        return buildUnion(node.oneOf, root, visited, node);
+    }
+    const type = node.type;
+    if (type === "string")
+        return buildString(node);
+    if (type === "number" || type === "integer")
+        return buildNumber(node);
+    if (type === "boolean")
+        return maybeDescribe(z.boolean(), node);
+    if (type === "array") {
+        const items = convertNode(node.items, root, visited);
+        return maybeDescribe(z.array(items), node);
+    }
+    if (type === "object" || node.properties) {
+        return buildObject(node, root, visited);
+    }
+    if (type === "null")
+        return z.null();
+    return z.any();
+}
+/**
+ * @param {JsonSchema[]} variants
+ * @param {JsonSchema} root
+ * @param {Set<string>} visited
+ * @param {JsonSchema} parent
+ * @returns {z.ZodType}
+ */
+function buildAnyOf(variants, root, visited, parent) {
+    const nullIdx = variants.findIndex((v) => v.type === "null");
+    if (nullIdx !== -1 && variants.length === 2) {
+        const other = variants[1 - nullIdx];
+        const inner = convertNode(other, root, visited);
+        const result = inner.nullable();
+        return parent.default !== undefined ? maybeDefault(maybeDescribe(result, parent), parent) : maybeDescribe(result, parent);
+    }
+    return buildUnion(variants, root, visited, parent);
+}
+/**
+ * @param {JsonSchema} s
+ * @returns {z.ZodType}
+ */
+function buildString(s) {
+    let schema;
+    if (s.enum && Array.isArray(s.enum) && s.enum.length > 0) {
+        schema = z.enum(s.enum);
+    }
+    else {
+        let str = z.string();
+        if (s.minLength !== undefined)
+            str = str.min(s.minLength);
+        if (s.maxLength !== undefined)
+            str = str.max(s.maxLength);
+        if (s.pattern)
+            str = str.regex(new RegExp(s.pattern));
+        schema = str;
+    }
+    return maybeDescribe(maybeNullable(maybeDefault(schema, s), s), s);
+}
+/**
+ * @param {JsonSchema} s
+ * @returns {z.ZodType}
+ */
+function buildNumber(s) {
+    let num = z.number();
+    if (s.type === "integer")
+        num = num.int();
+    if (s.minimum !== undefined)
+        num = num.min(s.minimum);
+    if (s.maximum !== undefined)
+        num = num.max(s.maximum);
+    return maybeDescribe(maybeNullable(maybeDefault(num, s), s), s);
+}
+/**
+ * @param {JsonSchema} s
+ * @param {JsonSchema} root
+ * @param {Set<string>} visited
+ * @returns {z.ZodType}
+ */
+function buildObject(s, root, visited) {
+    const props = {};
+    const required = new Set(s.required ?? []);
+    for (const [key, propSchema] of Object.entries(s.properties ?? {})) {
+        let zodProp = convertNode(propSchema, root, visited);
+        if (!required.has(key)) {
+            zodProp = zodProp.optional();
+        }
+        props[key] = zodProp;
+    }
+    const obj = z.object(props);
+    return maybeDescribe(maybeNullable(obj, s), s);
+}
+/**
+ * @param {JsonSchema[]} variants
+ * @param {JsonSchema} root
+ * @param {Set<string>} visited
+ * @param {JsonSchema} parent
+ * @returns {z.ZodType}
+ */
+function buildUnion(variants, root, visited, parent) {
+    const schemas = variants.map((v) => convertNode(v, root, visited));
+    if (schemas.length === 0)
+        return z.any();
+    if (schemas.length === 1)
+        return maybeDescribe(schemas[0], parent);
+    return maybeDescribe(z.union(schemas), parent);
+}
+/**
+ * @param {z.ZodType} schema
+ * @param {JsonSchema} s
+ * @returns {z.ZodType}
+ */
+function maybeDescribe(schema, s) {
+    if (s.description)
+        return schema.describe(s.description);
+    return schema;
+}
+/**
+ * @param {z.ZodType} schema
+ * @param {JsonSchema} s
+ * @returns {z.ZodType}
+ */
+function maybeNullable(schema, s) {
+    if (s.nullable)
+        return schema.nullable();
+    return schema;
+}
+/**
+ * @param {z.ZodType} schema
+ * @param {JsonSchema} s
+ * @returns {z.ZodType}
+ */
+function maybeDefault(schema, s) {
+    if (s.default !== undefined)
+        return schema.default(s.default);
+    return schema;
+}
+/**
+ * @param {JsonSchema} root
+ * @param {string} ref
+ * @returns {JsonSchema}
+ */
+function resolveJsonPointer(root, ref) {
+    if (!ref.startsWith("#/")) {
+        throw new Error(`Unsupported $ref format: ${ref}`);
+    }
+    const parts = ref.slice(2).split("/");
+    let current = root;
+    for (const part of parts) {
+        const decoded = part.replace(/~1/g, "/").replace(/~0/g, "~");
+        current = current?.[decoded];
+        if (current === undefined) {
+            throw new Error(`Could not resolve $ref: ${ref}`);
+        }
+    }
+    return current;
+}

package/src/getDefinedToolMetadata.js

@@ -0,0 +1,10 @@
+const smithersToolMetadata = Symbol.for("smithers.tool.metadata");
+/**
+ * @param {unknown} value
+ * @returns {| { name: string; sideEffect: boolean; idempotent: boolean; } | null}
+ */
+export function getDefinedToolMetadata(value) {
+    return value && typeof value === "object"
+        ? (value[smithersToolMetadata] ?? null)
+        : null;
+}

package/src/hot/HotReloadEvent.ts

@@ -0,0 +1,21 @@
+import type { SmithersWorkflow } from "@smithers-orchestrator/components/SmithersWorkflow";
+
+export type HotReloadEvent =
+	| {
+			type: "reloaded";
+			generation: number;
+			changedFiles: string[];
+			newBuild: SmithersWorkflow<unknown>["build"];
+	  }
+	| {
+			type: "failed";
+			generation: number;
+			changedFiles: string[];
+			error: unknown;
+	  }
+	| {
+			type: "unsafe";
+			generation: number;
+			changedFiles: string[];
+			reason: string;
+	  };

package/src/hot/HotWorkflowController.js

@@ -0,0 +1,220 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./HotReloadEvent.ts").HotReloadEvent} HotReloadEvent */
+// @smithers-type-exports-end
+
+import { resolve, dirname } from "node:path";
+import { mkdir, rm } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { Effect } from "effect";
+import { WatchTree } from "./watch.js";
+import { buildOverlayEffect, cleanupGenerationsEffect, resolveOverlayEntry, } from "./overlay.js";
+import { Metric } from "effect";
+import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
+import { logInfo, logWarning } from "@smithers-orchestrator/observability/logging";
+import { hotReloads, hotReloadFailures, hotReloadDuration } from "@smithers-orchestrator/observability/metrics";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+/** @typedef {import("@smithers-orchestrator/driver/RunOptions").HotReloadOptions} HotReloadOptions */
+
+const DEFAULT_MAX_GENERATIONS = 3;
+const DEFAULT_DEBOUNCE_MS = 100;
+export class HotWorkflowController {
+    entryPath;
+    hotRoot;
+    outDir;
+    maxGenerations;
+    watcher;
+    generation = 0;
+    closed = false;
+    /**
+   * @param {string} entryPath
+   * @param {HotReloadOptions} [opts]
+   */
+    constructor(entryPath, opts) {
+        this.entryPath = resolve(entryPath);
+        this.hotRoot = opts?.rootDir
+            ? resolve(opts.rootDir)
+            : dirname(this.entryPath);
+        this.outDir = opts?.outDir
+            ? resolve(opts.outDir)
+            : resolve(this.hotRoot, ".smithers", "hmr");
+        this.maxGenerations = opts?.maxGenerations ?? DEFAULT_MAX_GENERATIONS;
+        this.watcher = new WatchTree(this.hotRoot, {
+            debounceMs: opts?.debounceMs ?? DEFAULT_DEBOUNCE_MS,
+        });
+    }
+    /** Initialize: start file watchers. Call once before using wait/reload. */
+    async init() {
+        await Effect.runPromise(this.initEffect());
+    }
+    /** Current generation number. */
+    get gen() {
+        return this.generation;
+    }
+    /**
+     * Wait for the next file change event.
+     * Returns the list of changed file paths.
+     * Use this in Promise.race with inflight tasks to wake the engine loop.
+     */
+    async wait() {
+        return Effect.runPromise(this.waitEffect());
+    }
+    /**
+     * Perform a hot reload:
+     * 1. Build a new generation overlay
+     * 2. Import the workflow module from the overlay
+     * 3. Validate the module
+     * 4. Return the result (reloaded, failed, or unsafe)
+     *
+     * The caller is responsible for swapping workflow.build on success.
+     *
+     * @param {string[]} changedFiles
+     * @returns {Promise<HotReloadEvent>}
+     */
+    async reload(changedFiles) {
+        return Effect.runPromise(this.reloadEffect(changedFiles));
+    }
+    initEffect() {
+        return Effect.gen(this, function* () {
+            yield* Effect.tryPromise({
+                try: () => mkdir(this.outDir, { recursive: true }),
+                catch: (cause) => toSmithersError(cause, "create hot reload output dir"),
+            });
+            yield* this.watcher.startEffect();
+            yield* Effect.sync(() => {
+                logInfo("initialized hot workflow controller", {
+                    entryPath: this.entryPath,
+                    hotRoot: this.hotRoot,
+                    outDir: this.outDir,
+                }, "hot:controller");
+            });
+        }).pipe(Effect.annotateLogs({
+            entryPath: this.entryPath,
+            hotRoot: this.hotRoot,
+            outDir: this.outDir,
+        }), Effect.withLogSpan("hot:init"));
+    }
+    waitEffect() {
+        return this.watcher.waitEffect().pipe(Effect.annotateLogs({
+            entryPath: this.entryPath,
+            generation: this.generation,
+        }), Effect.withLogSpan("hot:wait"));
+    }
+    /**
+   * @param {string[]} changedFiles
+   */
+    reloadEffect(changedFiles) {
+        this.generation += 1;
+        const gen = this.generation;
+        const entryPath = this.entryPath;
+        const hotRoot = this.hotRoot;
+        const outDir = this.outDir;
+        const maxGenerations = this.maxGenerations;
+        return Effect.gen(this, function* () {
+            const reloadStart = performance.now();
+            const genDir = yield* buildOverlayEffect(hotRoot, outDir, gen);
+            const overlayEntry = resolveOverlayEntry(entryPath, hotRoot, genDir);
+            const overlayUrl = pathToFileURL(overlayEntry).href;
+            const mod = yield* Effect.either(Effect.tryPromise({
+                try: () => import(overlayUrl),
+                catch: (cause) => toSmithersError(cause, "import hot workflow generation"),
+            }));
+            if (mod._tag === "Left") {
+                logWarning("hot workflow import failed", {
+                    entryPath,
+                    generation: gen,
+                    changedFileCount: changedFiles.length,
+                    error: mod.left instanceof Error ? mod.left.message : String(mod.left),
+                }, "hot:reload");
+                return { type: "failed", generation: gen, changedFiles, error: mod.left };
+            }
+            const workflow = mod.right.default;
+            if (!workflow) {
+                return {
+                    type: "failed",
+                    generation: gen,
+                    changedFiles,
+                    error: new SmithersError("HOT_RELOAD_INVALID_MODULE", "Reloaded module does not export default", { changedFiles, entryPath, generation: gen }),
+                };
+            }
+            if (typeof workflow.build !== "function") {
+                return {
+                    type: "failed",
+                    generation: gen,
+                    changedFiles,
+                    error: new SmithersError("HOT_RELOAD_INVALID_MODULE", "Reloaded module default does not have a build function", { changedFiles, entryPath, generation: gen }),
+                };
+            }
+            yield* cleanupGenerationsEffect(outDir, maxGenerations);
+            yield* Metric.increment(hotReloads);
+            yield* Metric.update(hotReloadDuration, performance.now() - reloadStart);
+            logInfo("reloaded hot workflow generation", {
+                entryPath,
+                generation: gen,
+                changedFileCount: changedFiles.length,
+            }, "hot:reload");
+            return {
+                type: "reloaded",
+                generation: gen,
+                changedFiles,
+                newBuild: workflow.build,
+            };
+        }).pipe(Effect.catchAll((err) => Effect.gen(function* () {
+            yield* Metric.increment(hotReloadFailures);
+            if (err instanceof Error && err.message?.includes("Schema change detected")) {
+                logWarning("hot workflow reload marked unsafe", {
+                    entryPath,
+                    generation: gen,
+                    changedFileCount: changedFiles.length,
+                    reason: err.message,
+                }, "hot:reload");
+                return {
+                    type: "unsafe",
+                    generation: gen,
+                    changedFiles,
+                    reason: err.message,
+                };
+            }
+            logWarning("hot workflow reload failed", {
+                entryPath,
+                generation: gen,
+                changedFileCount: changedFiles.length,
+                error: err instanceof Error ? err.message : String(err),
+            }, "hot:reload");
+            return {
+                type: "failed",
+                generation: gen,
+                changedFiles,
+                error: err,
+            };
+        })), Effect.annotateLogs({
+            entryPath,
+            hotRoot,
+            generation: gen,
+        }), Effect.withLogSpan("hot:reload"));
+    }
+    /** Stop watchers and clean up overlay directory. */
+    async close() {
+        await Effect.runPromise(this.closeEffect());
+    }
+    closeEffect() {
+        return Effect.gen(this, function* () {
+            if (this.closed)
+                return;
+            this.closed = true;
+            this.watcher.close();
+            yield* Effect.either(Effect.tryPromise({
+                try: () => rm(this.outDir, { recursive: true, force: true }),
+                catch: (cause) => toSmithersError(cause, "remove hot reload output dir"),
+            }));
+            logInfo("closed hot workflow controller", {
+                entryPath: this.entryPath,
+                outDir: this.outDir,
+                generation: this.generation,
+            }, "hot:controller");
+        }).pipe(Effect.annotateLogs({
+            entryPath: this.entryPath,
+            outDir: this.outDir,
+            generation: this.generation,
+        }), Effect.withLogSpan("hot:close"));
+    }
+}