zudojs-cli 1.2.0 → 2.0.0

package/dist/src/registries/adapter/frontendAdapterRegistry.core.d.ts

@@ -12,8 +12,14 @@ export declare class FrontendAdapterRegistry {
     constructor();
     /**
      * Registers a new frontend adapter.
+     *
+     * A duplicate name used to overwrite the adapter already registered,
+     * silently, so the winner depended on registration order. Use
+     * {@link replace} to do that on purpose.
      */
     register(adapter: FrontendAdapter): void;
+    /** Registers an adapter, replacing any adapter of the same name. */
+    replace(adapter: FrontendAdapter): void;
     /**
      * Gets an adapter by name.
      */

package/dist/src/registries/adapter/frontendAdapterRegistry.core.js

@@ -3,6 +3,7 @@
  *
  * @module registries/adapter
  */
+import { CLIValidationError } from "../../errors/index.js";
 import { ReactAdapter } from "../../adapters/frontend/react.adapter.js";
 import { NextAdapter } from "../../adapters/frontend/next.adapter.js";
 import { VueAdapter } from "../../adapters/frontend/vue.adapter.js";
@@ -34,8 +35,19 @@ export class FrontendAdapterRegistry {
     }
     /**
      * Registers a new frontend adapter.
+     *
+     * A duplicate name used to overwrite the adapter already registered,
+     * silently, so the winner depended on registration order. Use
+     * {@link replace} to do that on purpose.
      */
     register(adapter) {
+        if (this.adapters.has(adapter.name)) {
+            throw new CLIValidationError(`A frontend adapter named "${adapter.name}" is already registered. Use replace() to override it.`);
+        }
+        this.adapters.set(adapter.name, adapter);
+    }
+    /** Registers an adapter, replacing any adapter of the same name. */
+    replace(adapter) {
         this.adapters.set(adapter.name, adapter);
     }
     /**

package/dist/src/registries/adapter/packageManagerRegistry.core.d.ts

@@ -12,8 +12,13 @@ export declare class PackageManagerRegistry {
     constructor();
     /**
      * Registers a new package manager adapter.
+     *
+     * Registering the same name twice used to overwrite the first adapter
+     * without a word; {@link replace} is the explicit way to do that.
      */
     register(adapter: PackageManager): void;
+    /** Registers an adapter, replacing any adapter of the same name. */
+    replace(adapter: PackageManager): void;
     /**
      * Gets an adapter by name.
      */

package/dist/src/registries/adapter/packageManagerRegistry.core.js

@@ -3,6 +3,7 @@
  *
  * @module registries/adapter/packageManager
  */
+import { CLIValidationError } from "../../errors/index.js";
 import { PnpmAdapter } from "../../adapters/package-managers/pnpm.adapter.js";
 import { NpmAdapter } from "../../adapters/package-managers/npm.adapter.js";
 import { YarnAdapter } from "../../adapters/package-managers/yarn.adapter.js";
@@ -20,8 +21,18 @@ export class PackageManagerRegistry {
     }
     /**
      * Registers a new package manager adapter.
+     *
+     * Registering the same name twice used to overwrite the first adapter
+     * without a word; {@link replace} is the explicit way to do that.
      */
     register(adapter) {
+        if (this.adapters.has(adapter.name)) {
+            throw new CLIValidationError(`A package manager adapter named "${adapter.name}" is already registered. Use replace() to override it.`);
+        }
+        this.adapters.set(adapter.name, adapter);
+    }
+    /** Registers an adapter, replacing any adapter of the same name. */
+    replace(adapter) {
         this.adapters.set(adapter.name, adapter);
     }
     /**

package/dist/src/registries/dependency/dependencyRegistry.core.d.ts

@@ -11,7 +11,16 @@ export interface DependencyRecord {
 }
 export declare class DependencyRegistry {
     private readonly dependencies;
+    /**
+     * Records a dependency.
+     *
+     * A second record for the same package used to overwrite the first one
+     * silently, which hid version disagreements between two callers. Use
+     * {@link replace} when overwriting is the intent.
+     */
     add(record: DependencyRecord): void;
+    /** Records a dependency, replacing any record of the same name. */
+    replace(record: DependencyRecord): void;
     addMany(records: readonly DependencyRecord[]): void;
     get(name: string): DependencyRecord | undefined;
     getAll(): readonly DependencyRecord[];

package/dist/src/registries/dependency/dependencyRegistry.core.js

@@ -3,9 +3,25 @@
  *
  * Registry for tracking and managing project dependencies.
  */
+import { CLIValidationError } from "../../errors/index.js";
 export class DependencyRegistry {
     dependencies = new Map();
+    /**
+     * Records a dependency.
+     *
+     * A second record for the same package used to overwrite the first one
+     * silently, which hid version disagreements between two callers. Use
+     * {@link replace} when overwriting is the intent.
+     */
     add(record) {
+        const existing = this.dependencies.get(record.name);
+        if (existing !== undefined) {
+            throw new CLIValidationError(`Dependency "${record.name}" is already registered as ${existing.version} (${existing.source}). Use replace() to override it.`);
+        }
+        this.dependencies.set(record.name, record);
+    }
+    /** Records a dependency, replacing any record of the same name. */
+    replace(record) {
         this.dependencies.set(record.name, record);
     }
     addMany(records) {

package/dist/src/registries/generator/generatorRegistry.core.d.ts

@@ -11,7 +11,15 @@ export interface GeneratorRegistryEntry {
 export declare class GeneratorRegistry {
     private readonly generators;
     constructor();
+    /**
+     * Registers a generator.
+     *
+     * A duplicate name used to replace the previous entry silently, so which
+     * generator ran depended on registration order.
+     */
     register(entry: GeneratorRegistryEntry): void;
+    /** Registers a generator, replacing any entry of the same name. */
+    replace(entry: GeneratorRegistryEntry): void;
     get(name: string): GeneratorRegistryEntry | undefined;
     getByCapability(capability: string): GeneratorRegistryEntry[];
     getNames(): readonly string[];

package/dist/src/registries/generator/generatorRegistry.core.js

@@ -3,6 +3,7 @@
  *
  * Registry for project generators with capability-based lookup.
  */
+import { CLIValidationError } from "../../errors/index.js";
 import { BackendGenerator } from "../../generators/backend/backend.generator.js";
 import { FrontendGenerator } from "../../generators/frontend/frontendGenerator.core.js";
 import { FullstackComposer } from "../../generators/fullstack/fullstackComposer.core.js";
@@ -49,7 +50,20 @@ export class GeneratorRegistry {
             capabilities: ["docker", "database", "microservice"],
         });
     }
+    /**
+     * Registers a generator.
+     *
+     * A duplicate name used to replace the previous entry silently, so which
+     * generator ran depended on registration order.
+     */
     register(entry) {
+        if (this.generators.has(entry.name)) {
+            throw new CLIValidationError(`A generator named "${entry.name}" is already registered. Use replace() to override it.`);
+        }
+        this.generators.set(entry.name, entry);
+    }
+    /** Registers a generator, replacing any entry of the same name. */
+    replace(entry) {
         this.generators.set(entry.name, entry);
     }
     get(name) {

package/dist/src/resolvers/capability/capabilityResolver.core.d.ts

@@ -9,8 +9,8 @@ export interface CapabilityDependency {
 }
 export interface CapabilityResolutionResult {
     readonly capabilities: readonly string[];
+    /** Framework packages the selected capabilities build on. */
     readonly dependencies: readonly string[];
-    readonly conflicts: readonly string[];
 }
 export declare class CapabilityResolver {
     private readonly dependencyGraph;

package/dist/src/resolvers/capability/capabilityResolver.core.js

@@ -37,7 +37,6 @@ export class CapabilityResolver {
     resolve(capabilities) {
         const resolved = new Set();
         const dependencies = new Set();
-        const conflicts = [];
         for (const capability of capabilities) {
             if (resolved.has(capability))
                 continue;
@@ -52,7 +51,6 @@ export class CapabilityResolver {
         return {
             capabilities: Array.from(resolved),
             dependencies: Array.from(dependencies),
-            conflicts,
         };
     }
     getCapabilities() {

package/dist/src/resolvers/layout/projectLayout.core.js

@@ -19,6 +19,7 @@
  *
  * @module resolvers/layout
  */
+import { PACKAGE_MANAGERS } from "../../constants/index.js";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { SAFE_PATH_SEGMENT } from "../../utils/utils.name.js";
@@ -27,12 +28,6 @@ const PROJECT_TYPES = [
     "frontend",
     "fullstack",
 ];
-const PACKAGE_MANAGERS = [
-    "pnpm",
-    "npm",
-    "yarn",
-    "bun",
-];
 function readJson(path) {
     try {
         const parsed = JSON.parse(readFileSync(path, "utf-8"));

package/dist/src/resolvers/project.resolver.d.ts

@@ -1,7 +1,13 @@
 /**
- * Walks upward from `startDir` to the nearest directory that looks like a
- * project root: one holding a `.zudojs/manifest.json`, a legacy
- * `zudojs.config.ts`, or a `package.json`.
+ * Walks upward from `startDir` to the nearest directory that really is a
+ * Zudojs project — one `resolveProjectLayout` recognizes: a
+ * `.zudojs/manifest.json`, a legacy `zudojs.config.ts`/`.js`, or a `zudojs`
+ * block in `package.json`.
+ *
+ * A bare `package.json` used to be accepted too, which made this a
+ * "any JavaScript project" detector rather than a Zudojs one: run from a
+ * directory with no Zudojs project anywhere, `zudojs build` climbed to an
+ * unrelated ancestor `package.json` and ran its `scripts.build`.
  */
 export declare function findProjectRoot(startDir?: string): string | null;
 export declare function resolveProjectPath(cwd: string, name: string): string;

package/dist/src/resolvers/project.resolver.js

@@ -1,16 +1,20 @@
-import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { resolveProjectLayout } from "./layout/projectLayout.core.js";
 /**
- * Walks upward from `startDir` to the nearest directory that looks like a
- * project root: one holding a `.zudojs/manifest.json`, a legacy
- * `zudojs.config.ts`, or a `package.json`.
+ * Walks upward from `startDir` to the nearest directory that really is a
+ * Zudojs project — one `resolveProjectLayout` recognizes: a
+ * `.zudojs/manifest.json`, a legacy `zudojs.config.ts`/`.js`, or a `zudojs`
+ * block in `package.json`.
+ *
+ * A bare `package.json` used to be accepted too, which made this a
+ * "any JavaScript project" detector rather than a Zudojs one: run from a
+ * directory with no Zudojs project anywhere, `zudojs build` climbed to an
+ * unrelated ancestor `package.json` and ran its `scripts.build`.
  */
 export function findProjectRoot(startDir = process.cwd()) {
     let dir = startDir;
     while (true) {
-        if (existsSync(join(dir, ".zudojs", "manifest.json")) ||
-            existsSync(join(dir, "zudojs.config.ts")) ||
-            existsSync(join(dir, "package.json"))) {
+        if (resolveProjectLayout(dir) !== null) {
             return dir;
         }
         const parent = dirname(dir);

package/dist/src/rollback/index.d.ts

@@ -3,5 +3,5 @@
  *
  * Rollback system barrel exports.
  */
-export { RollbackManager, type RollbackEntry } from "./rollbackManager.core.js";
+export { RollbackManager, type RollbackEntry, type RollbackFailure, type RollbackResult, } from "./rollbackManager.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/rollback/index.js

@@ -3,5 +3,5 @@
  *
  * Rollback system barrel exports.
  */
-export { RollbackManager } from "./rollbackManager.core.js";
+export { RollbackManager, } from "./rollbackManager.core.js";
 //# sourceMappingURL=index.js.map

package/dist/src/rollback/rollbackManager.core.d.ts

@@ -8,11 +8,29 @@ export interface RollbackEntry {
     readonly path: string;
     readonly timestamp: number;
 }
+/** One entry that could not be removed, with the reason. */
+export interface RollbackFailure {
+    readonly path: string;
+    readonly reason: string;
+}
+/** What a rollback actually managed to undo. */
+export interface RollbackResult {
+    readonly removed: readonly string[];
+    readonly failures: readonly RollbackFailure[];
+}
 export declare class RollbackManager {
     private readonly entries;
     trackFile(path: string): void;
     trackDirectory(path: string): void;
-    rollback(): Promise<void>;
+    /**
+     * Removes every tracked path, newest first.
+     *
+     * Failures used to be swallowed and the entry list cleared regardless, so
+     * a half-created project stayed on disk with nothing left to retry and
+     * nothing said about it. Entries that could not be removed are kept, and
+     * the caller is handed the paths so it can name them.
+     */
+    rollback(): Promise<RollbackResult>;
     get entriesCount(): number;
     clear(): void;
 }

package/dist/src/rollback/rollbackManager.core.js

@@ -21,21 +21,40 @@ export class RollbackManager {
             timestamp: Date.now(),
         });
     }
+    /**
+     * Removes every tracked path, newest first.
+     *
+     * Failures used to be swallowed and the entry list cleared regardless, so
+     * a half-created project stayed on disk with nothing left to retry and
+     * nothing said about it. Entries that could not be removed are kept, and
+     * the caller is handed the paths so it can name them.
+     */
     async rollback() {
+        const removed = [];
+        const failures = [];
+        const remaining = [];
         for (const entry of [...this.entries].reverse()) {
             try {
                 if (entry.type === "file" && existsSync(entry.path)) {
                     await rm(entry.path);
+                    removed.push(entry.path);
                 }
                 else if (entry.type === "directory" && existsSync(entry.path)) {
                     await rm(entry.path, { recursive: true, force: true });
+                    removed.push(entry.path);
                 }
             }
-            catch {
-                // Best-effort rollback
+            catch (error) {
+                failures.push({
+                    path: entry.path,
+                    reason: error instanceof Error ? error.message : String(error),
+                });
+                remaining.push(entry);
             }
         }
         this.entries.length = 0;
+        this.entries.push(...remaining);
+        return { removed, failures };
     }
     get entriesCount() {
         return this.entries.length;

package/dist/src/runners/package-manager/index.d.ts

@@ -3,5 +3,5 @@
  *
  * Runners for package manager operations.
  */
-export { PackageManagerRunner, type PackageManagerRunOptions, } from "./packageManagerRunner.core.js";
+export { PackageManagerRunner, assertPackageManager, type PackageManagerRunOptions, } from "./packageManagerRunner.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/runners/package-manager/index.js

@@ -3,5 +3,5 @@
  *
  * Runners for package manager operations.
  */
-export { PackageManagerRunner, } from "./packageManagerRunner.core.js";
+export { PackageManagerRunner, assertPackageManager, } from "./packageManagerRunner.core.js";
 //# sourceMappingURL=index.js.map

package/dist/src/runners/package-manager/packageManagerRunner.core.d.ts

@@ -3,13 +3,25 @@
  *
  * Runner for package manager operations (install, add, remove, run).
  */
+import type { PackageManager } from "../../types/index.js";
 export interface PackageManagerRunOptions {
     readonly cwd: string;
     readonly args: readonly string[];
 }
+/** The package managers this runner will put in the executable position. */
+/**
+ * Narrows an untrusted value to a supported package manager.
+ *
+ * The constructor argument ends up as the executable name of a spawned
+ * process, so it is checked at runtime as well as at compile time: this is
+ * public API and a JavaScript caller gets no type checking at all.
+ *
+ * @throws {CLIValidationError} If the value is not a known package manager.
+ */
+export declare function assertPackageManager(value: string): PackageManager;
 export declare class PackageManagerRunner {
     private readonly manager;
-    constructor(manager: string);
+    constructor(manager: PackageManager);
     install(cwd: string): Promise<void>;
     add(packages: readonly string[], options: PackageManagerRunOptions): Promise<void>;
     addDev(packages: readonly string[], options: PackageManagerRunOptions): Promise<void>;

package/dist/src/runners/package-manager/packageManagerRunner.core.js

@@ -3,11 +3,29 @@
  *
  * Runner for package manager operations (install, add, remove, run).
  */
+import { PACKAGE_MANAGERS } from "../../constants/index.js";
+import { CLIValidationError } from "../../errors/index.js";
 import { execCommand } from "../../utils/utils.exec.js";
+/** The package managers this runner will put in the executable position. */
+/**
+ * Narrows an untrusted value to a supported package manager.
+ *
+ * The constructor argument ends up as the executable name of a spawned
+ * process, so it is checked at runtime as well as at compile time: this is
+ * public API and a JavaScript caller gets no type checking at all.
+ *
+ * @throws {CLIValidationError} If the value is not a known package manager.
+ */
+export function assertPackageManager(value) {
+    if (!PACKAGE_MANAGERS.includes(value)) {
+        throw new CLIValidationError(`Unsupported package manager: "${value}". Expected one of ${PACKAGE_MANAGERS.join(", ")}.`);
+    }
+    return value;
+}
 export class PackageManagerRunner {
     manager;
     constructor(manager) {
-        this.manager = manager;
+        this.manager = assertPackageManager(manager);
     }
     async install(cwd) {
         const args = this.manager === "pnpm"

package/dist/src/runners/process/processRunner.core.d.ts

@@ -18,6 +18,17 @@ export declare class ProcessRunner {
         stderr: string;
         exitCode: number;
     }>;
+    /**
+     * Starts a process and resolves once it has actually spawned.
+     *
+     * A raw `spawn` with no `'error'` listener turns an ENOENT into an
+     * unhandled `'error'` event, which terminates the CLI itself — and the
+     * old implementation had already returned `{ pid: 0 }`, so no caller
+     * could catch it. The failure is now a rejection, and the command goes
+     * through {@link resolveSpawnTarget} so Windows `.cmd` shims work.
+     *
+     * @throws {Error} If the process cannot be started.
+     */
     runBackground(command: string, args: readonly string[], options: ProcessOptions): Promise<{
         pid: number;
     }>;

package/dist/src/runners/process/processRunner.core.js

@@ -3,7 +3,7 @@
  *
  * Runner for executing system processes.
  */
-import { execCommand } from "../../utils/utils.exec.js";
+import { execCommand, resolveChildEnv, resolveSpawnTarget, } from "../../utils/utils.exec.js";
 export class ProcessRunner {
     async run(command, args, options) {
         try {
@@ -29,14 +29,49 @@ export class ProcessRunner {
             return { stdout, stderr, exitCode };
         }
     }
+    /**
+     * Starts a process and resolves once it has actually spawned.
+     *
+     * A raw `spawn` with no `'error'` listener turns an ENOENT into an
+     * unhandled `'error'` event, which terminates the CLI itself — and the
+     * old implementation had already returned `{ pid: 0 }`, so no caller
+     * could catch it. The failure is now a rejection, and the command goes
+     * through {@link resolveSpawnTarget} so Windows `.cmd` shims work.
+     *
+     * @throws {Error} If the process cannot be started.
+     */
     async runBackground(command, args, options) {
         const { spawn } = await import("node:child_process");
-        const child = spawn(command, Array.from(args), {
-            cwd: options.cwd,
-            env: { ...process.env, ...options.env },
-            stdio: options.stdio ?? "ignore",
+        const target = resolveSpawnTarget(command, Array.from(args));
+        const env = resolveChildEnv(target.shell, {
+            ...process.env,
+            ...options.env,
+        });
+        return await new Promise((resolve, reject) => {
+            const child = spawn(target.file, target.args, {
+                cwd: options.cwd,
+                env,
+                stdio: options.stdio ?? "ignore",
+                shell: target.shell,
+            });
+            let settled = false;
+            child.on("error", (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (error.code === "ENOENT") {
+                    reject(new Error(`Command "${command}" was not found. Install it and make sure it is on your PATH.`));
+                    return;
+                }
+                reject(error);
+            });
+            child.on("spawn", () => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve({ pid: child.pid ?? 0 });
+            });
         });
-        return { pid: child.pid ?? 0 };
     }
 }
 //# sourceMappingURL=processRunner.core.js.map

package/dist/src/runners/task/index.d.ts

@@ -3,5 +3,5 @@
  *
  * Runners for executing development tasks.
  */
-export { TaskRunner, type TaskDefinition, type TaskResult, } from "./taskRunner.core.js";
+export { TaskRunner, type TaskDefinition, type TaskResult, type TaskRunOptions, } from "./taskRunner.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/runners/task/taskRunner.core.d.ts

@@ -8,16 +8,37 @@ export interface TaskDefinition {
     readonly command: string;
     readonly args: readonly string[];
     readonly cwd: string;
+    /**
+     * When true, a failure of this task cancels the other tasks of the same
+     * {@link TaskRunner.runParallel} batch. Defaults to false.
+     */
     readonly required?: boolean;
 }
 export interface TaskResult {
     readonly task: string;
     readonly success: boolean;
+    /** The child's exit code, or -1 when it never exited normally. */
     readonly exitCode: number;
+    /** The child's stdout. */
     readonly output: string;
+    /** The child's stderr, or the reason it could not be run. */
+    readonly stderr: string;
+    /** True when the task was cancelled because a required task failed. */
+    readonly cancelled: boolean;
+}
+export interface TaskRunOptions {
+    /** Aborting the signal terminates the task's child process. */
+    readonly signal?: AbortSignal;
 }
 export declare class TaskRunner {
-    run(task: TaskDefinition): Promise<TaskResult>;
+    run(task: TaskDefinition, options?: TaskRunOptions): Promise<TaskResult>;
+    /**
+     * Runs every task concurrently.
+     *
+     * A task marked `required` that fails aborts the tasks still running:
+     * there is no point building the rest of a project once a prerequisite
+     * step has failed. Those tasks come back with `cancelled: true`.
+     */
     runParallel(tasks: readonly TaskDefinition[]): Promise<readonly TaskResult[]>;
 }
 //# sourceMappingURL=taskRunner.core.d.ts.map

package/dist/src/runners/task/taskRunner.core.js

@@ -4,29 +4,58 @@
  * Runner for executing development tasks (dev servers, builds, tests).
  */
 import { execCommand } from "../../utils/utils.exec.js";
+/** Exit code reported for a child that never exited with a status. */
+const NO_EXIT_CODE = -1;
+function readString(source, key) {
+    const value = source?.[key];
+    return typeof value === "string" ? value : "";
+}
 export class TaskRunner {
-    async run(task) {
+    async run(task, options = {}) {
         try {
-            await execCommand(task.command, Array.from(task.args), task.cwd);
+            const result = await execCommand(task.command, Array.from(task.args), task.cwd, { ...(options.signal ? { signal: options.signal } : {}) });
             return {
                 task: task.name,
                 success: true,
                 exitCode: 0,
-                output: "",
+                output: result.stdout,
+                stderr: result.stderr,
+                cancelled: false,
             };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
+            const cancelled = error instanceof Error &&
+                error.name === "AbortError" &&
+                options.signal?.aborted === true;
+            const code = error.code;
+            const stderr = readString(error, "stderr");
             return {
                 task: task.name,
                 success: false,
-                exitCode: 1,
-                output: message,
+                exitCode: typeof code === "number" ? code : NO_EXIT_CODE,
+                output: readString(error, "stdout"),
+                stderr: stderr !== "" ? stderr : message,
+                cancelled,
             };
         }
     }
+    /**
+     * Runs every task concurrently.
+     *
+     * A task marked `required` that fails aborts the tasks still running:
+     * there is no point building the rest of a project once a prerequisite
+     * step has failed. Those tasks come back with `cancelled: true`.
+     */
     async runParallel(tasks) {
-        const results = await Promise.all(tasks.map((task) => this.run(task)));
+        const controller = new AbortController();
+        const results = await Promise.all(tasks.map(async (task) => {
+            const result = await this.run(task, { signal: controller.signal });
+            if (!result.success && task.required === true) {
+                controller.abort();
+            }
+            return result;
+        }));
         return results;
     }
 }

package/dist/src/scaffolders/framework.scaffolder.js

@@ -4,12 +4,15 @@
  * Invokes official framework scaffolders to create projects.
  */
 import { execCommand } from "../utils/utils.exec.js";
+import { SCAFFOLD_TIMEOUT_MS } from "./scaffolder.helper.js";
 export class FrameworkScaffolder {
     async scaffold(targetPath) {
         try {
             await execCommand(this.command, this.args, targetPath, {
                 // Suppress interactive prompts from create-* tools.
                 env: { ...process.env, CI: "1" },
+                // Registry downloads outrun the default 2-minute probe timeout.
+                timeout: SCAFFOLD_TIMEOUT_MS,
             });
             return { success: true, path: targetPath };
         }