@simplysm/sd-cli 13.0.75 → 13.0.77

package/src/orchestrators/DevOrchestrator.ts

@@ -1,6 +1,6 @@
 import path from "path";
 import { Worker, type WorkerProxy } from "@simplysm/core-node";
-import { errorMessage } from "@simplysm/core-common";
+import { err as errNs } from "@simplysm/core-common";
 import type { SdConfig, SdClientPackageConfig, SdServerPackageConfig } from "../sd-config.types";
 import { consola } from "consola";
 import { loadSdConfig } from "../utils/sd-config";
@@ -16,7 +16,6 @@ import { formatBuildMessages, printErrors, printServers } from "../utils/output-
 import { RebuildManager } from "../utils/rebuild-manager";
 import {
   registerWorkerEventHandlers,
-  type BaseWorkerInfo,
   type ServerReadyEventData,
   type ServerBuildEventData,
   type ErrorEventData,
@@ -45,6 +44,19 @@ interface ClientWorkerInfo {
   buildResolver: (() => void) | undefined;
 }
 
+/**
+ * Options for client worker setup
+ */
+interface ClientSetupOptions {
+  workers: ClientWorkerInfo[];
+  /** Called on serverReady event. If undefined, completeTask is called with running status. */
+  onServerReady?: (workerInfo: ClientWorkerInfo, port: number, completeTask: (result: BuildResult) => void) => void;
+  /** Called on error event (in addition to default error handling) */
+  onError?: (workerInfo: ClientWorkerInfo) => void;
+  /** Create the config to pass to worker.startWatch() */
+  createConfig: (workerInfo: ClientWorkerInfo) => SdClientPackageConfig;
+}
+
 //#endregion
 
 //#region DevOrchestrator
@@ -130,7 +142,7 @@ export class DevOrchestrator {
       this._sdConfig = await loadSdConfig({
         cwd: this._cwd,
         dev: true,
-        opt: this._options.options,
+        options: this._options.options,
       });
       this._logger.debug("sd.config.ts loaded successfully");
     } catch (err) {
@@ -236,9 +248,54 @@ export class DevOrchestrator {
       }));
 
     // Setup and start workers for each section
-    const standaloneClientPromises = this._setupStandaloneClients();
-    const { buildPromises: viteClientPromises, readyPromises: viteClientReadyPromises } =
-      this._setupViteClients();
+    const standaloneClientPromises = this._setupClientWorkers({
+      workers: this._standaloneClientWorkers,
+      createConfig: (workerInfo) => ({
+        ...workerInfo.config,
+        env: { ...this._baseEnv, ...workerInfo.config.env },
+      }),
+    });
+
+    // Vite client ready promises (server waits for client ports before starting runtime)
+    const viteClientReadyPromises = new Map<string, { promise: Promise<void>; resolver: () => void }>();
+    for (const workerInfo of this._viteClientWorkers) {
+      let readyResolver!: () => void;
+      const readyPromise = new Promise<void>((resolve) => {
+        readyResolver = resolve;
+      });
+      viteClientReadyPromises.set(workerInfo.name, {
+        promise: readyPromise,
+        resolver: readyResolver,
+      });
+    }
+
+    const viteClientPromises = this._setupClientWorkers({
+      workers: this._viteClientWorkers,
+      onServerReady: (workerInfo, port, completeTask) => {
+        this._logger.debug(`[${workerInfo.name}] Vite serverReady (port: ${String(port)})`);
+        this._clientPorts[workerInfo.name] = port;
+        // Notify Vite server ready (server is waiting for proxy setup)
+        viteClientReadyPromises.get(workerInfo.name)?.resolver();
+        // Call completeTask for build completion (Vite doesn't emit build event)
+        completeTask({
+          name: workerInfo.name,
+          target: workerInfo.config.target,
+          type: "build",
+          status: "success",
+        });
+      },
+      onError: (workerInfo) => {
+        // Also resolve readyPromises on Vite client error
+        // (prevent server from hanging indefinitely in await Promise.all(clientReadyPromises))
+        viteClientReadyPromises.get(workerInfo.name)?.resolver();
+      },
+      createConfig: (workerInfo) => ({
+        ...workerInfo.config,
+        server: 0, // Vite will automatically assign port
+        env: { ...this._baseEnv, ...workerInfo.config.env },
+      }),
+    });
+
     const serverPromises = this._setupServers(
       serverWorkerPath,
       serverRuntimeWorkerPath,
@@ -295,7 +352,7 @@ export class DevOrchestrator {
             target: "client",
             type: "capacitor",
             status: "error",
-            message: errorMessage(err),
+            message: errNs.message(err),
           });
           this._logger.fail(taskName);
         }
@@ -308,11 +365,11 @@ export class DevOrchestrator {
   }
 
   /**
-   * Setup and start standalone client workers
+   * Setup and start client workers (unified for standalone and server-connected clients)
    */
-  private _setupStandaloneClients(): Array<{ name: string; promise: Promise<void> }> {
+  private _setupClientWorkers(opts: ClientSetupOptions): Array<{ name: string; promise: Promise<void> }> {
     const buildPromises = new Map<string, Promise<void>>();
-    for (const workerInfo of this._standaloneClientWorkers) {
+    for (const workerInfo of opts.workers) {
       buildPromises.set(
         workerInfo.name,
         new Promise<void>((resolve) => {
@@ -322,9 +379,9 @@ export class DevOrchestrator {
     }
 
     // Register event handlers
-    for (const workerInfo of this._standaloneClientWorkers) {
+    for (const workerInfo of opts.workers) {
       const completeTask = registerWorkerEventHandlers(
-        workerInfo as unknown as BaseWorkerInfo,
+        workerInfo,
         {
           resultKey: `${workerInfo.name}:build`,
           listrTitle: `${workerInfo.name} (client)`,
@@ -337,112 +394,25 @@ export class DevOrchestrator {
       // serverReady (Vite dev server)
       workerInfo.worker.on("serverReady", (data) => {
         const event = data as ServerReadyEventData;
-        completeTask({
-          name: workerInfo.name,
-          target: workerInfo.config.target,
-          type: "server",
-          status: "running",
-          port: event.port,
-        });
-      });
-
-      // Print server URL when scope package rebuild is detected
-      workerInfo.worker.on("scopeRebuild", () => {
-        this._schedulePrintServers();
-      });
-
-      // Start worker
-      const pkgDir = path.join(this._cwd, "packages", workerInfo.name);
-      const clientConfig: SdClientPackageConfig = {
-        ...workerInfo.config,
-        env: { ...this._baseEnv, ...workerInfo.config.env },
-      };
-      workerInfo.worker
-        .startWatch({
-          name: workerInfo.name,
-          config: clientConfig,
-          cwd: this._cwd,
-          pkgDir,
-          replaceDeps: this._sdConfig!.replaceDeps,
-        })
-        .catch((err: unknown) => {
+        if (opts.onServerReady != null) {
+          opts.onServerReady(workerInfo, event.port, completeTask);
+        } else {
           completeTask({
             name: workerInfo.name,
             target: workerInfo.config.target,
-            type: "build",
-            status: "error",
-            message: errorMessage(err),
+            type: "server",
+            status: "running",
+            port: event.port,
           });
-        });
-    }
-
-    return this._standaloneClientWorkers.map((workerInfo) => ({
-      name: `${workerInfo.name} (client)`,
-      promise: buildPromises.get(workerInfo.name) ?? Promise.resolve(),
-    }));
-  }
-
-  /**
-   * Setup and start Vite client (server-connected) workers
-   */
-  private _setupViteClients(): {
-    buildPromises: Array<{ name: string; promise: Promise<void> }>;
-    readyPromises: Map<string, { promise: Promise<void>; resolver: () => void }>;
-  } {
-    const buildPromiseMap = new Map<string, Promise<void>>();
-    const readyPromises = new Map<string, { promise: Promise<void>; resolver: () => void }>();
-    for (const workerInfo of this._viteClientWorkers) {
-      buildPromiseMap.set(
-        workerInfo.name,
-        new Promise<void>((resolve) => {
-          workerInfo.buildResolver = resolve;
-        }),
-      );
-      // Vite server ready promise (wait until server knows client port)
-      let readyResolver!: () => void;
-      const readyPromise = new Promise<void>((resolve) => {
-        readyResolver = resolve;
-      });
-      readyPromises.set(workerInfo.name, {
-        promise: readyPromise,
-        resolver: readyResolver,
+        }
       });
-    }
 
-    // Register event handlers
-    for (const workerInfo of this._viteClientWorkers) {
-      const completeTask = registerWorkerEventHandlers(
-        workerInfo as unknown as BaseWorkerInfo,
-        {
-          resultKey: `${workerInfo.name}:build`,
-          listrTitle: `${workerInfo.name} (client)`,
-          resultType: "build",
-        },
-        this._results,
-        this._rebuildManager,
-      );
-
-      // serverReady - Store Vite port in clientPorts (URL is printed via server)
-      workerInfo.worker.on("serverReady", (data) => {
-        const event = data as ServerReadyEventData;
-        this._logger.debug(`[${workerInfo.name}] Vite serverReady (port: ${String(event.port)})`);
-        this._clientPorts[workerInfo.name] = event.port;
-        // Notify Vite server ready (server is waiting for proxy setup)
-        readyPromises.get(workerInfo.name)?.resolver();
-        // Call completeTask for build completion (Vite doesn't emit build event)
-        completeTask({
-          name: workerInfo.name,
-          target: workerInfo.config.target,
-          type: "build",
-          status: "success",
+      // Additional error handling (in addition to default from registerWorkerEventHandlers)
+      if (opts.onError != null) {
+        workerInfo.worker.on("error", () => {
+          opts.onError!(workerInfo);
         });
-      });
-
-      // Also resolve readyPromises on Vite client error
-      // (prevent server from hanging indefinitely in await Promise.all(clientReadyPromises))
-      workerInfo.worker.on("error", () => {
-        readyPromises.get(workerInfo.name)?.resolver();
-      });
+      }
 
       // Print server URL when scope package rebuild is detected
       workerInfo.worker.on("scopeRebuild", () => {
@@ -451,16 +421,11 @@ export class DevOrchestrator {
 
       // Start worker
       const pkgDir = path.join(this._cwd, "packages", workerInfo.name);
-      // Allow Vite to automatically assign port
-      const viteConfig: SdClientPackageConfig = {
-        ...workerInfo.config,
-        server: 0, // Vite will automatically assign port
-        env: { ...this._baseEnv, ...workerInfo.config.env },
-      };
+      const clientConfig = opts.createConfig(workerInfo);
       workerInfo.worker
         .startWatch({
           name: workerInfo.name,
-          config: viteConfig,
+          config: clientConfig,
           cwd: this._cwd,
           pkgDir,
           replaceDeps: this._sdConfig!.replaceDeps,
@@ -471,18 +436,15 @@ export class DevOrchestrator {
             target: workerInfo.config.target,
             type: "build",
             status: "error",
-            message: errorMessage(err),
+            message: errNs.message(err),
           });
         });
     }
 
-    return {
-      buildPromises: this._viteClientWorkers.map((workerInfo) => ({
-        name: `${workerInfo.name} (client)`,
-        promise: buildPromiseMap.get(workerInfo.name) ?? Promise.resolve(),
-      })),
-      readyPromises,
-    };
+    return opts.workers.map((workerInfo) => ({
+      name: `${workerInfo.name} (client)`,
+      promise: buildPromises.get(workerInfo.name) ?? Promise.resolve(),
+    }));
   }
 
   /**
@@ -519,13 +481,28 @@ export class DevOrchestrator {
       serverRuntimePromises.set(name, { promise, resolver });
     }
 
+    // Track first build state per server
+    const isFirstBuild = new Map<string, boolean>(
+      this._serverPackages.map(({ name }) => [name, true])
+    );
+
+    // Helper to encapsulate result + promise resolution pattern
+    const resolveServerStep = (serverName: string, resultKey: string, result: BuildResult): void => {
+      this._results.set(resultKey, result);
+      if (isFirstBuild.get(serverName)) {
+        isFirstBuild.set(serverName, false);
+        serverRuntimePromises.get(serverName)?.resolver();
+      }
+      const updatedBuild = this._serverBuildWorkers.get(serverName)!;
+      updatedBuild.buildResolver();
+    };
+
     // Register Server Build Worker event handlers
     for (const { name } of this._serverPackages) {
       const serverBuild = this._serverBuildWorkers.get(name)!;
-      let isFirstBuild = true;
 
       serverBuild.worker.on("buildStart", () => {
-        if (!isFirstBuild) {
+        if (!isFirstBuild.get(name)) {
           // Register with RebuildManager on rebuild
           const resolver = this._rebuildManager.registerBuild(`${name}:server`, `${name} (server)`);
           this._serverBuildWorkers.set(name, {
@@ -545,162 +522,47 @@ export class DevOrchestrator {
         }
 
         if (!event.success) {
-          this._results.set(`${name}:build`, {
+          resolveServerStep(name, `${name}:build`, {
             name,
             target: "server",
             type: "build",
             status: "error",
             message: event.errors?.join("\n"),
           });
-
-          if (isFirstBuild) {
-            isFirstBuild = false;
-            serverRuntimePromises.get(name)?.resolver();
-          }
-          this._serverBuildWorkers.get(name)!.buildResolver();
           return;
         }
 
         // Start runtime worker on build success (separate async function to prevent error propagation)
-        void startServerRuntime(name, event.mainJsPath).catch((err: unknown) => {
-          const message = errorMessage(err);
+        void this._startServerRuntime(
+          name,
+          event.mainJsPath,
+          serverRuntimeWorkerPath,
+          serverRuntimePromises,
+          resolveServerStep,
+          viteClientReadyPromises,
+        ).catch((err: unknown) => {
+          const message = errNs.message(err);
           this._logger.error(`[${name}] Error starting Server Runtime:`, message);
 
-          this._results.set(`${name}:server`, {
+          resolveServerStep(name, `${name}:server`, {
             name,
             target: "server",
             type: "server",
             status: "error",
             message,
           });
-
-          if (isFirstBuild) {
-            isFirstBuild = false;
-            serverRuntimePromises.get(name)?.resolver();
-          }
-          const updatedBuild = this._serverBuildWorkers.get(name)!;
-          updatedBuild.buildResolver();
         });
       });
 
-      /**
-       * Start server runtime worker.
-       * Separated as a dedicated function to catch errors from async event handlers.
-       */
-      const startServerRuntime = async (serverName: string, mainJsPath: string): Promise<void> => {
-        this._logger.debug(`[${serverName}] startServerRuntime: ${mainJsPath}`);
-        const updatedBuild = this._serverBuildWorkers.get(serverName)!;
-        updatedBuild.mainJsPath = mainJsPath;
-
-        // Terminate existing Server Runtime Worker
-        const existingRuntime = this._serverRuntimeWorkers.get(serverName);
-        if (existingRuntime != null) {
-          this._logger.info(`[${serverName}] Restarting server...`);
-          await existingRuntime.terminate();
-        }
-
-        // Create and start new Server Runtime Worker
-        const runtimeWorker =
-          Worker.create<typeof ServerRuntimeWorkerModule>(serverRuntimeWorkerPath);
-        this._serverRuntimeWorkers.set(serverName, runtimeWorker);
-
-        // Wait for Vite servers of clients connected to this server to be ready
-        const connectedClients = this._serverClientsMap.get(serverName) ?? [];
-        const clientReadyPromises = connectedClients
-          .map((clientName) => viteClientReadyPromises.get(clientName)?.promise)
-          .filter((p): p is Promise<void> => p != null);
-        this._logger.debug(
-          `[${serverName}] Waiting for clients: ${String(clientReadyPromises.length)} total`,
-        );
-        if (clientReadyPromises.length > 0) {
-          await Promise.all(clientReadyPromises);
-        }
-
-        // Collect client ports for this server
-        const serverClientPorts: Record<string, number> = {};
-        for (const clientName of connectedClients) {
-          if (clientName in this._clientPorts) {
-            serverClientPorts[clientName] = this._clientPorts[clientName];
-          }
-        }
-
-        // Server Runtime event handlers
-        runtimeWorker.on("serverReady", (readyData) => {
-          const readyEvent = readyData as ServerReadyEventData;
-          this._results.set(`${serverName}:server`, {
-            name: serverName,
-            target: "server",
-            type: "server",
-            status: "running",
-            port: readyEvent.port,
-          });
-
-          if (isFirstBuild) {
-            isFirstBuild = false;
-            serverRuntimePromises.get(serverName)?.resolver();
-          }
-          updatedBuild.buildResolver();
-        });
-
-        runtimeWorker.on("error", (errorData) => {
-          const errorEvent = errorData as ErrorEventData;
-          this._results.set(`${serverName}:server`, {
-            name: serverName,
-            target: "server",
-            type: "server",
-            status: "error",
-            message: errorEvent.message,
-          });
-
-          if (isFirstBuild) {
-            isFirstBuild = false;
-            serverRuntimePromises.get(serverName)?.resolver();
-          }
-          updatedBuild.buildResolver();
-        });
-
-        // Start Server Runtime
-        // If worker crashes, it terminates without emitting "serverReady"/"error" events,
-        // so catch promise rejection to prevent hanging
-        runtimeWorker
-          .start({
-            mainJsPath,
-            clientPorts: serverClientPorts,
-          })
-          .catch((err: unknown) => {
-            const message = errorMessage(err);
-            this._logger.error(`[${serverName}] Server Runtime Worker crashed:`, message);
-
-            this._results.set(`${serverName}:server`, {
-              name: serverName,
-              target: "server",
-              type: "server",
-              status: "error",
-              message,
-            });
-
-            if (isFirstBuild) {
-              isFirstBuild = false;
-              serverRuntimePromises.get(serverName)?.resolver();
-            }
-            updatedBuild.buildResolver();
-          });
-      };
-
       serverBuild.worker.on("error", (data) => {
         const event = data as ErrorEventData;
-        this._results.set(`${name}:build`, {
+        resolveServerStep(name, `${name}:build`, {
           name,
           target: "server",
           type: "build",
           status: "error",
           message: event.message,
         });
-        if (isFirstBuild) {
-          isFirstBuild = false;
-          serverRuntimePromises.get(name)?.resolver();
-        }
-        this._serverBuildWorkers.get(name)!.buildResolver();
       });
     }
 
@@ -724,7 +586,7 @@ export class DevOrchestrator {
             target: "server",
             type: "build",
             status: "error",
-            message: errorMessage(err),
+            message: errNs.message(err),
           });
           serverRuntimePromises.get(name)?.resolver();
           serverBuild.buildResolver();
@@ -737,6 +599,98 @@ export class DevOrchestrator {
     }));
   }
 
+  /**
+   * Start server runtime worker.
+   * Separated as a dedicated method to catch errors from async event handlers.
+   */
+  private async _startServerRuntime(
+    serverName: string,
+    mainJsPath: string,
+    serverRuntimeWorkerPath: string,
+    serverRuntimePromises: Map<string, { promise: Promise<void>; resolver: () => void }>,
+    resolveServerStep: (serverName: string, resultKey: string, result: BuildResult) => void,
+    viteClientReadyPromises: Map<string, { promise: Promise<void>; resolver: () => void }>,
+  ): Promise<void> {
+    this._logger.debug(`[${serverName}] _startServerRuntime: ${mainJsPath}`);
+    const updatedBuild = this._serverBuildWorkers.get(serverName)!;
+    updatedBuild.mainJsPath = mainJsPath;
+
+    // Terminate existing Server Runtime Worker
+    const existingRuntime = this._serverRuntimeWorkers.get(serverName);
+    if (existingRuntime != null) {
+      this._logger.info(`[${serverName}] Restarting server...`);
+      await existingRuntime.terminate();
+    }
+
+    // Create and start new Server Runtime Worker
+    const runtimeWorker = Worker.create<typeof ServerRuntimeWorkerModule>(serverRuntimeWorkerPath);
+    this._serverRuntimeWorkers.set(serverName, runtimeWorker);
+
+    // Wait for Vite servers of clients connected to this server to be ready
+    const connectedClients = this._serverClientsMap.get(serverName) ?? [];
+    const clientReadyPromises = connectedClients
+      .map((clientName) => viteClientReadyPromises.get(clientName)?.promise)
+      .filter((p): p is Promise<void> => p != null);
+    this._logger.debug(
+      `[${serverName}] Waiting for clients: ${String(clientReadyPromises.length)} total`,
+    );
+    if (clientReadyPromises.length > 0) {
+      await Promise.all(clientReadyPromises);
+    }
+
+    // Collect client ports for this server
+    const serverClientPorts: Record<string, number> = {};
+    for (const clientName of connectedClients) {
+      if (clientName in this._clientPorts) {
+        serverClientPorts[clientName] = this._clientPorts[clientName];
+      }
+    }
+
+    // Server Runtime event handlers
+    runtimeWorker.on("serverReady", (readyData) => {
+      const readyEvent = readyData as ServerReadyEventData;
+      resolveServerStep(serverName, `${serverName}:server`, {
+        name: serverName,
+        target: "server",
+        type: "server",
+        status: "running",
+        port: readyEvent.port,
+      });
+    });
+
+    runtimeWorker.on("error", (errorData) => {
+      const errorEvent = errorData as ErrorEventData;
+      resolveServerStep(serverName, `${serverName}:server`, {
+        name: serverName,
+        target: "server",
+        type: "server",
+        status: "error",
+        message: errorEvent.message,
+      });
+    });
+
+    // Start Server Runtime
+    // If worker crashes, it terminates without emitting "serverReady"/"error" events,
+    // so catch promise rejection to prevent hanging
+    runtimeWorker
+      .start({
+        mainJsPath,
+        clientPorts: serverClientPorts,
+      })
+      .catch((err: unknown) => {
+        const message = errNs.message(err);
+        this._logger.error(`[${serverName}] Server Runtime Worker crashed:`, message);
+
+        resolveServerStep(serverName, `${serverName}:server`, {
+          name: serverName,
+          target: "server",
+          type: "server",
+          status: "error",
+          message,
+        });
+      });
+  }
+
   /**
    * Wait for termination signal
    */

package/src/orchestrators/WatchOrchestrator.ts

@@ -1,6 +1,6 @@
 import path from "path";
 import { consola } from "consola";
-import type { BuildTarget, SdConfig, SdPackageConfig } from "../sd-config.types";
+import type { BuildTarget, SdBuildPackageConfig, SdConfig } from "../sd-config.types";
 import { loadSdConfig } from "../utils/sd-config";
 import { filterPackagesByTargets } from "../utils/package-utils";
 import { watchReplaceDeps, type WatchReplaceDepResult } from "../utils/replace-deps";
@@ -10,10 +10,9 @@ import { ResultCollector } from "../infra/ResultCollector";
 import { SignalHandler } from "../infra/SignalHandler";
 import { LibraryBuilder } from "../builders/LibraryBuilder";
 import { DtsBuilder } from "../builders/DtsBuilder";
-import type { PackageInfo } from "../builders/types";
+import type { BuildPackageInfo } from "../builders/types";
 import { watchCopySrcFiles } from "../utils/copy-src";
 import type { FsWatcher } from "@simplysm/core-node";
-import type { SdBuildPackageConfig } from "../sd-config.types";
 
 /**
  * Watch command options
@@ -40,7 +39,7 @@ export class WatchOrchestrator {
   private _rebuildManager!: RebuildManager;
   private _libraryBuilder!: LibraryBuilder;
   private _dtsBuilder!: DtsBuilder;
-  private _packages: PackageInfo[] = [];
+  private _packages: BuildPackageInfo[] = [];
   private _copySrcWatchers: FsWatcher[] = [];
   private _replaceDepWatcher: WatchReplaceDepResult | undefined;
 
@@ -64,7 +63,7 @@ export class WatchOrchestrator {
       sdConfig = await loadSdConfig({
         cwd: this._cwd,
         dev: true,
-        opt: this._options.options,
+        options: this._options.options,
       });
       this._logger.debug("sd.config.ts loaded");
     } catch (err) {
@@ -85,10 +84,10 @@ export class WatchOrchestrator {
     const isLibraryTarget = (target: string): target is BuildTarget =>
       target === "node" || target === "browser" || target === "neutral";
 
-    const libraryConfigs: Record<string, SdPackageConfig> = {};
+    const libraryConfigs: Record<string, SdBuildPackageConfig> = {};
     for (const [name, config] of Object.entries(allPackages)) {
       if (isLibraryTarget(config.target)) {
-        libraryConfigs[name] = config;
+        libraryConfigs[name] = config as SdBuildPackageConfig;
       }
     }
 
@@ -145,9 +144,8 @@ export class WatchOrchestrator {
 
     // Start copySrc watch
     for (const pkg of this._packages) {
-      const buildConfig = pkg.config as SdBuildPackageConfig;
-      if (buildConfig.copySrc != null && buildConfig.copySrc.length > 0) {
-        const watcher = await watchCopySrcFiles(pkg.dir, buildConfig.copySrc);
+      if (pkg.config.copySrc != null && pkg.config.copySrc.length > 0) {
+        const watcher = await watchCopySrcFiles(pkg.dir, pkg.config.copySrc);
         this._copySrcWatchers.push(watcher);
       }
     }

package/src/sd-cli.ts

@@ -30,7 +30,7 @@ if (isDev) {
   try {
     const { loadSdConfig } = await import("./utils/sd-config.js");
     const { setupReplaceDeps } = await import("./utils/replace-deps.js");
-    const sdConfig = await loadSdConfig({ cwd: process.cwd(), dev: false, opt: [] });
+    const sdConfig = await loadSdConfig({ cwd: process.cwd(), dev: false, options: [] });
     if (sdConfig.replaceDeps != null) {
       await setupReplaceDeps(process.cwd(), sdConfig.replaceDeps);
     }