@wordpress-flow/cli 1.0.21 → 1.0.23

package/dist/build/block-build-worker.js

@@ -1835,7 +1835,7 @@ import { parentPort, workerData } from "worker_threads";
 import * as path from "path";
 import * as fs from "fs";
 import * as esbuild from "esbuild";
-import { execSync } from "child_process";
+import webpack from "webpack";
 async function buildBlock() {
   const { block, outputDir, webpackConfigPath, scriptsPath, tempDir } = workerData;
   try {
@@ -2002,26 +2002,35 @@ function parseBlockJsonFromSource(block) {
   };
 }
 async function runWebpackBuild(entryPoint, outputDir, webpackConfigPath) {
-  const webpackBinary = findWebpackBinary();
-  const envString = `--env entry="${entryPoint}" --env output="${outputDir}"`;
-  const command = `${webpackBinary} --config "${webpackConfigPath}" ${envString} --mode production`;
-  execSync(command, {
-    cwd: path.dirname(webpackConfigPath),
-    encoding: "utf8",
-    stdio: "pipe"
-  });
-}
-function findWebpackBinary() {
-  const possiblePaths = [
-    path.join(process.cwd(), "packages", "block", "node_modules", ".bin", "webpack"),
-    path.join(process.cwd(), "node_modules", ".bin", "webpack")
-  ];
-  for (const webpackPath of possiblePaths) {
-    if (fs.existsSync(webpackPath)) {
-      return webpackPath;
+  delete __require.cache[__require.resolve(webpackConfigPath)];
+  const configModule = __require(webpackConfigPath);
+  const configFactory = configModule.default || configModule;
+  const env = { entry: entryPoint, output: outputDir };
+  const baseConfig = typeof configFactory === "function" ? configFactory(env) : configFactory;
+  const config = {
+    ...baseConfig,
+    mode: "production",
+    entry: entryPoint,
+    output: {
+      ...baseConfig.output,
+      path: outputDir
     }
-  }
-  return "npx webpack";
+  };
+  return new Promise((resolve2, reject) => {
+    webpack(config, (err, stats) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      if (stats?.hasErrors()) {
+        const info = stats.toJson();
+        reject(new Error(info.errors?.map((e) => e.message).join(`
+`) || "Webpack build failed"));
+        return;
+      }
+      resolve2();
+    });
+  });
 }
 function verifyBuildOutput(outputDir) {
   const requiredFiles = ["block.json", "index.js", "ssr.js"];

package/dist/index.js

@@ -114193,7 +114193,7 @@ var watch = (paths, options) => {
 var $watch = watch;
 
 // src/commands/dev-command.ts
-import * as path16 from "path";
+import * as path15 from "path";
 import * as fs14 from "fs";
 
 // src/build/block-scanner.ts
@@ -114258,17 +114258,12 @@ class BlockScanner {
 
 // src/build/block-builder.ts
 import * as fs10 from "fs";
-import * as path10 from "path";
+import * as path9 from "path";
 
 // src/build/webpack-runner.ts
-import * as path8 from "path";
 import * as fs8 from "fs";
-import { execSync } from "child_process";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import webpack from "webpack";
 var import_chalk3 = __toESM(require_source(), 1);
-var __filename2 = fileURLToPath4(import.meta.url);
-var __dirname2 = path8.dirname(__filename2);
-
 class WebpackRunner {
   async runBuild(entryPoint, outputDir, webpackConfigPath) {
     logger.debug(`Running webpack build for: ${entryPoint}`);
@@ -114287,85 +114282,74 @@ class WebpackRunner {
       throw new Error(error);
     }
     fs8.mkdirSync(outputDir, { recursive: true });
-    const webpackBinary = this.findWebpackBinary();
-    logger.debug(`Using webpack binary: ${webpackBinary}`);
-    const envVars = {
-      entry: entryPoint,
-      output: outputDir
-    };
-    const envString = Object.entries(envVars).map(([key, value]) => `--env ${key}="${value}"`).join(" ");
-    const command = `${webpackBinary} --config "${webpackConfigPath}" ${envString} --mode production`;
-    logger.debug(`Full command: ${command}`);
     try {
-      const workingDir = path8.dirname(webpackConfigPath);
-      logger.debug(`Running webpack from directory: ${workingDir}`);
-      const output2 = execSync(command, {
-        cwd: workingDir,
-        encoding: "utf8",
-        stdio: "pipe"
+      delete __require.cache[__require.resolve(webpackConfigPath)];
+      const configModule = __require(webpackConfigPath);
+      const configFactory = configModule.default || configModule;
+      const env2 = { entry: entryPoint, output: outputDir };
+      const baseConfig = typeof configFactory === "function" ? configFactory(env2) : configFactory;
+      const config2 = {
+        ...baseConfig,
+        mode: "production",
+        entry: entryPoint,
+        output: {
+          ...baseConfig.output,
+          path: outputDir
+        }
+      };
+      logger.debug(`Running webpack with config for: ${entryPoint}`);
+      await new Promise((resolve4, reject) => {
+        webpack(config2, (err, stats) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          if (stats?.hasErrors()) {
+            const info = stats.toJson();
+            reject(new Error(info.errors?.map((e) => e.message).join(`
+`) || "Webpack build failed"));
+            return;
+          }
+          if (stats?.hasWarnings()) {
+            const info = stats.toJson();
+            info.warnings?.forEach((w) => logger.debug(`Webpack warning: ${w.message}`));
+          }
+          resolve4();
+        });
       });
       logger.debug("Webpack build completed successfully");
-      logger.debug(`Output: ${output2}`);
     } catch (error) {
       console.error("");
       console.error(import_chalk3.default.red("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
       console.error(import_chalk3.default.red.bold("  WEBPACK BUILD FAILED"));
       console.error(import_chalk3.default.red("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
       console.error("");
-      console.error(import_chalk3.default.yellow("Command that failed:"));
-      console.error(import_chalk3.default.gray(command));
+      console.error(import_chalk3.default.yellow("Entry point:"));
+      console.error(import_chalk3.default.gray(entryPoint));
       console.error("");
-      console.error(import_chalk3.default.yellow("Working directory:"));
-      console.error(import_chalk3.default.gray(path8.dirname(webpackConfigPath)));
+      console.error(import_chalk3.default.yellow("Output directory:"));
+      console.error(import_chalk3.default.gray(outputDir));
+      console.error("");
+      console.error(import_chalk3.default.yellow("Error message:"));
+      console.error(import_chalk3.default.gray(error.message));
       console.error("");
-      if (error.stdout && error.stdout.trim()) {
-        console.error(import_chalk3.default.yellow("Standard output:"));
-        console.error(error.stdout);
-        console.error("");
-      }
-      if (error.stderr && error.stderr.trim()) {
-        console.error(import_chalk3.default.yellow("Error output:"));
-        console.error(error.stderr);
-        console.error("");
-      }
-      if (!error.stdout && !error.stderr) {
-        console.error(import_chalk3.default.yellow("Error message:"));
-        console.error(error.message);
-        console.error("");
-      }
       console.error(import_chalk3.default.red("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
       console.error("");
-      throw new Error(`Webpack build failed`);
-    }
-  }
-  findWebpackBinary() {
-    const possiblePaths = [
-      path8.join(process.cwd(), "packages", "block", "node_modules", ".bin", "webpack"),
-      path8.join(process.cwd(), "node_modules", ".bin", "webpack"),
-      path8.join(__dirname2, "..", "..", "..", "node_modules", ".bin", "webpack"),
-      path8.join(process.cwd(), "..", "node_modules", ".bin", "webpack")
-    ];
-    for (const webpackPath of possiblePaths) {
-      if (fs8.existsSync(webpackPath)) {
-        logger.debug(`Found webpack at: ${webpackPath}`);
-        return webpackPath;
-      }
+      throw new Error(`Webpack build failed: ${error.message}`);
     }
-    logger.debug("Using npx webpack as fallback");
-    return "npx webpack";
   }
 }
 
 // src/build/script-builder.ts
 import * as fs9 from "fs";
-import * as path9 from "path";
+import * as path8 from "path";
 import * as esbuild from "esbuild";
 class ScriptBuilder {
   async buildScript(scriptPath, outputDir, scriptName) {
     try {
       logger.debug(`Building script: ${scriptName}`);
       fs9.mkdirSync(outputDir, { recursive: true });
-      const outputPath = path9.join(outputDir, scriptName.replace(/\.ts$/, ".js"));
+      const outputPath = path8.join(outputDir, scriptName.replace(/\.ts$/, ".js"));
       await esbuild.build({
         entryPoints: [scriptPath],
         outfile: outputPath,
@@ -114395,19 +114379,19 @@ class ScriptBuilder {
   async buildScripts(scripts, scriptsPath, outputDir) {
     const outputPaths = [];
     for (const script of scripts) {
-      const scriptPath = path9.resolve(scriptsPath, script);
+      const scriptPath = path8.resolve(scriptsPath, script);
       if (!fs9.existsSync(scriptPath)) {
         logger.warn(`Script not found: ${scriptPath}`);
         continue;
       }
-      const scriptName = path9.basename(script);
+      const scriptName = path8.basename(script);
       const outputPath = await this.buildScript(scriptPath, outputDir, scriptName);
       outputPaths.push(outputPath);
     }
     return outputPaths;
   }
   getRelativeScriptPath(blockDistPath, scriptPath) {
-    const relativePath = path9.relative(blockDistPath, scriptPath);
+    const relativePath = path8.relative(blockDistPath, scriptPath);
     return relativePath.replace(/\\/g, "/");
   }
 }
@@ -114421,7 +114405,7 @@ class BlockBuilder {
   constructor() {
     this.webpackRunner = new WebpackRunner;
     this.scriptBuilder = new ScriptBuilder;
-    this.tempDir = path10.join(process.cwd(), ".wordpress-flow-temp");
+    this.tempDir = path9.join(process.cwd(), ".wordpress-flow-temp");
   }
   async buildBlock(block, outputDir, webpackConfigPath, scriptsPath) {
     logger.debug(`Building block: ${block.name}`);
@@ -114430,7 +114414,7 @@ class BlockBuilder {
       logger.debug(`[1/6] Generating entry point...`);
       const entryPoint = await this.generateEntryPoint(block);
       logger.debug(`[2/6] Creating output directory...`);
-      const blockOutputDir = path10.join(outputDir, block.name);
+      const blockOutputDir = path9.join(outputDir, block.name);
       fs10.mkdirSync(blockOutputDir, { recursive: true });
       let scriptPaths = [];
       if (block.scripts && block.scripts.length > 0 && scriptsPath) {
@@ -114458,7 +114442,7 @@ class BlockBuilder {
     }
   }
   async buildBlockScripts(scripts, scriptsPath, outputDir) {
-    const scriptsOutputDir = path10.join(path10.dirname(outputDir), "scripts");
+    const scriptsOutputDir = path9.join(path9.dirname(outputDir), "scripts");
     return await this.scriptBuilder.buildScripts(scripts, scriptsPath, scriptsOutputDir);
   }
   async generateEntryPoint(block) {
@@ -114482,14 +114466,14 @@ if (document.readyState === 'loading') {
   blockInstance.register();
 }
 `;
-    const entryPath = path10.join(this.tempDir, `${block.name}-entry.js`);
+    const entryPath = path9.join(this.tempDir, `${block.name}-entry.js`);
     fs10.writeFileSync(entryPath, entryContent, "utf8");
     return entryPath;
   }
   async generateSSRVersion(block, outputDir) {
     try {
       logger.debug(`Generating SSR version for ${block.name} using esbuild`);
-      const ssrPath = path10.join(outputDir, "ssr.js");
+      const ssrPath = path9.join(outputDir, "ssr.js");
       await esbuild2.build({
         entryPoints: [block.filePath],
         outfile: ssrPath,
@@ -114529,7 +114513,7 @@ if (document.readyState === 'loading') {
         throw new Error(`Block ${block.name} must export a valid block instance with toBlockJson() method`);
       }
       const blockJson = blockInstance.toBlockJson();
-      const blockJsonPath = path10.join(outputDir, "block.json");
+      const blockJsonPath = path9.join(outputDir, "block.json");
       fs10.writeFileSync(blockJsonPath, JSON.stringify(blockJson, null, 2), "utf8");
       logger.debug(`Generated block.json for ${block.name}`);
     } catch (error) {
@@ -114553,7 +114537,7 @@ if (document.readyState === 'loading') {
         editorStyle: "file:./index.css",
         style: "file:./style-index.css"
       };
-      const blockJsonPath = path10.join(outputDir, "block.json");
+      const blockJsonPath = path9.join(outputDir, "block.json");
       fs10.writeFileSync(blockJsonPath, JSON.stringify(fallbackBlockJson, null, 2), "utf8");
       logger.warn(`Used fallback block.json for ${block.name}`);
     }
@@ -114566,7 +114550,7 @@ if (document.readyState === 'loading') {
   }
   async compileAndImport(filePath2) {
     try {
-      const tempFile = path10.join(this.tempDir, `${path10.basename(filePath2, path10.extname(filePath2))}-compiled.js`);
+      const tempFile = path9.join(this.tempDir, `${path9.basename(filePath2, path9.extname(filePath2))}-compiled.js`);
       logger.debug(`Compiling ${filePath2} to ${tempFile}`);
       if (typeof global.React === "undefined") {
         global.React = require_react();
@@ -114596,7 +114580,7 @@ if (document.readyState === 'loading') {
   }
   parseBlockFromSource(filePath2) {
     const content4 = fs10.readFileSync(filePath2, "utf8");
-    const blockName = path10.basename(filePath2, ".tsx");
+    const blockName = path9.basename(filePath2, ".tsx");
     const blockData = this.extractBlockDataFromSource(content4, filePath2);
     return {
       toBlockJson: () => {
@@ -114706,13 +114690,13 @@ if (document.readyState === 'loading') {
     const requiredFiles = ["block.json", "index.js", "ssr.js"];
     const optionalFiles = ["index.asset.php", "index.css", "style-index.css"];
     for (const file of requiredFiles) {
-      const filePath2 = path10.join(outputDir, file);
+      const filePath2 = path9.join(outputDir, file);
       if (!fs10.existsSync(filePath2)) {
         throw new Error(`Required build output file missing: ${file}`);
       }
     }
     for (const file of optionalFiles) {
-      const filePath2 = path10.join(outputDir, file);
+      const filePath2 = path9.join(outputDir, file);
       if (fs10.existsSync(filePath2)) {
         logger.debug(`Generated optional file: ${file}`);
       }
@@ -114731,12 +114715,12 @@ if (document.readyState === 'loading') {
 
 // src/build/type-definition-generator.ts
 import * as fs11 from "fs";
-import * as path11 from "path";
+import * as path10 from "path";
 class TypeDefinitionGenerator {
   async generateDefinitions(blocks, outputPath) {
     logger.debug(`Generating TypeScript definitions for ${blocks.length} blocks`);
     const content4 = this.generateDefinitionContent(blocks);
-    const outputDir = path11.dirname(outputPath);
+    const outputDir = path10.dirname(outputPath);
     if (!fs11.existsSync(outputDir)) {
       fs11.mkdirSync(outputDir, { recursive: true });
     }
@@ -114842,7 +114826,7 @@ export {};
     const blockDirs = fs11.readdirSync(distDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     for (const blockDir of blockDirs) {
       try {
-        const blockJsonPath = path11.join(distDir, blockDir, "block.json");
+        const blockJsonPath = path10.join(distDir, blockDir, "block.json");
         if (fs11.existsSync(blockJsonPath)) {
           const blockJson = JSON.parse(fs11.readFileSync(blockJsonPath, "utf8"));
           const blockInfo = {
@@ -114874,7 +114858,7 @@ export {};
 
 // src/build/mdx-dependency-tracker.ts
 import * as fs12 from "fs";
-import * as path12 from "path";
+import * as path11 from "path";
 class MDXDependencyTracker {
   dependencies = new Map;
   reverseDependencies = new Map;
@@ -114886,7 +114870,7 @@ class MDXDependencyTracker {
     }
     this.dependencies.clear();
     this.reverseDependencies.clear();
-    const pattern = path12.join(contentDir, "**/*.mdx");
+    const pattern = path11.join(contentDir, "**/*.mdx");
     const mdxFiles = await glob(pattern);
     logger.debug(`Found ${mdxFiles.length} MDX files`);
     for (const filePath2 of mdxFiles) {
@@ -114925,7 +114909,7 @@ class MDXDependencyTracker {
         blocks.push(componentName);
       }
     }
-    logger.debug(`File ${path12.basename(filePath2)} uses blocks: ${blocks.join(", ")}`);
+    logger.debug(`File ${path11.basename(filePath2)} uses blocks: ${blocks.join(", ")}`);
     return blocks;
   }
   getDependentFiles(blockName) {
@@ -114960,13 +114944,13 @@ class MDXDependencyTracker {
   printDependencies() {
     logger.info("=== MDX Dependencies ===");
     for (const [filePath2, blocks] of this.dependencies.entries()) {
-      const fileName = path12.basename(filePath2);
+      const fileName = path11.basename(filePath2);
       logger.info(`${fileName}: [${blocks.join(", ")}]`);
     }
     logger.info(`
 === Reverse Dependencies ===`);
     for (const [blockName, files] of this.reverseDependencies.entries()) {
-      const fileNames = files.map((f) => path12.basename(f));
+      const fileNames = files.map((f) => path11.basename(f));
       logger.info(`${blockName}: [${fileNames.join(", ")}]`);
     }
     const stats = this.getStats();
@@ -114980,17 +114964,17 @@ class MDXDependencyTracker {
 }
 
 // src/commands/build-command.ts
-import * as path15 from "path";
+import * as path14 from "path";
 
 // src/build/php-generator.ts
 import * as fs13 from "fs";
-import * as path13 from "path";
+import * as path12 from "path";
 class PHPGenerator {
   generateScriptRegistrationPHP(scripts, outputPath) {
     const registrations = [];
     scripts.forEach((scriptPaths, blockName) => {
       scriptPaths.forEach((scriptPath, index2) => {
-        const scriptName = path13.basename(scriptPath, ".js");
+        const scriptName = path12.basename(scriptPath, ".js");
         const handle = `${blockName.toLowerCase()}-${scriptName}-script`;
         registrations.push({
           blockName,
@@ -115053,7 +115037,7 @@ add_action('enqueue_block_assets', 'wordpress_flow_enqueue_block_scripts');
   generateSingleRegistration(reg) {
     const deps = reg.dependencies.map((d) => `'${d}'`).join(", ");
     const scriptPath = reg.scriptPath.includes("dist/") ? reg.scriptPath : `dist/${reg.scriptPath}`;
-    return `    // ${reg.blockName} - ${path13.basename(reg.scriptPath)}
+    return `    // ${reg.blockName} - ${path12.basename(reg.scriptPath)}
     wp_register_script(
         '${reg.scriptHandle}',
         get_template_directory_uri() . '/${scriptPath}',
@@ -115066,11 +115050,11 @@ add_action('enqueue_block_assets', 'wordpress_flow_enqueue_block_scripts');
 
 // src/build/worker-pool.ts
 import { Worker } from "worker_threads";
-import * as path14 from "path";
+import * as path13 from "path";
 import * as os from "os";
-import { fileURLToPath as fileURLToPath5 } from "url";
-var __filename3 = fileURLToPath5(import.meta.url);
-var __dirname3 = path14.dirname(__filename3);
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __filename2 = fileURLToPath4(import.meta.url);
+var __dirname2 = path13.dirname(__filename2);
 
 class WorkerPool {
   concurrency;
@@ -115083,7 +115067,7 @@ class WorkerPool {
     this.outputDir = options.outputDir;
     this.webpackConfigPath = options.webpackConfigPath;
     this.scriptsPath = options.scriptsPath;
-    this.workerPath = path14.join(__dirname3, "build", "block-build-worker.js");
+    this.workerPath = path13.join(__dirname2, "build", "block-build-worker.js");
   }
   async buildAll(blocks, onProgress) {
     const results = [];
@@ -115130,7 +115114,7 @@ class WorkerPool {
   }
   buildBlockInWorker(block) {
     return new Promise((resolve5, reject) => {
-      const tempDir = path14.join(process.cwd(), ".wordpress-flow-temp", `worker-${block.name}-${Date.now()}`);
+      const tempDir = path13.join(process.cwd(), ".wordpress-flow-temp", `worker-${block.name}-${Date.now()}`);
       const workerData = {
         block: {
           name: block.name,
@@ -115237,7 +115221,7 @@ class BuildCommand {
         if (block.scripts && block.scripts.length > 0) {
           const result2 = results.find((r) => r.blockName === block.name);
           if (result2?.success) {
-            const scriptPaths = block.scripts.map((script) => `scripts/${path15.basename(script).replace(/\.ts$/, ".js")}`);
+            const scriptPaths = block.scripts.map((script) => `scripts/${path14.basename(script).replace(/\.ts$/, ".js")}`);
             this.blockScripts.set(block.name, scriptPaths);
           }
         }
@@ -115251,7 +115235,7 @@ Failed to build ${failures.length} block(s):`);
         }
       }
       if (this.blockScripts.size > 0) {
-        const phpPath = path15.join(path15.dirname(outputDir), "functions-blocks-scripts.php");
+        const phpPath = path14.join(path14.dirname(outputDir), "functions-blocks-scripts.php");
         this.phpGenerator.generateScriptRegistrationPHP(this.blockScripts, phpPath);
       }
       await this.generateTypeDefinitions(outputDir);
@@ -115275,7 +115259,7 @@ Failed to build ${failures.length} block(s):`);
         logger.warn("No blocks found for type generation");
         return;
       }
-      const typesPath = path15.join(outputDir, "blocks.d.ts");
+      const typesPath = path14.join(outputDir, "blocks.d.ts");
       await this.typeGenerator.generateDefinitions(blocks, typesPath);
       logger.success(`✅ Generated TypeScript definitions for ${blocks.length} block(s)`);
     } catch (error) {
@@ -115442,7 +115426,7 @@ class DevCommand {
     return new Promise(() => {});
   }
   handleFileEvent(eventType, filePath2, options) {
-    const fullPath = path16.resolve(this.configManager.resolvePath(this.configManager.getConfig().paths.mdxOutputDir), filePath2);
+    const fullPath = path15.resolve(this.configManager.resolvePath(this.configManager.getConfig().paths.mdxOutputDir), filePath2);
     logger.debug(`File ${eventType}: ${filePath2}`);
     if (eventType === "unlink") {
       logger.warn(`File deleted: ${filePath2} - Manual WordPress cleanup may be required`);
@@ -115461,7 +115445,7 @@ class DevCommand {
   }
   async handleLocalFileChange(filePath2, options) {
     try {
-      logger.info(`\uD83D\uDD04 Processing local file change: ${path16.relative(process.cwd(), filePath2)}`);
+      logger.info(`\uD83D\uDD04 Processing local file change: ${path15.relative(process.cwd(), filePath2)}`);
       await this.pushCommand.execute({
         files: [filePath2],
         force: options.conflictResolution === "local-wins",
@@ -115511,13 +115495,13 @@ class DevCommand {
   handleBlockFileEvent(eventType, filePath2, options) {
     const config2 = this.configManager.getConfig();
     const blocksDir = this.configManager.resolvePath(config2.build?.blocksDir || "./theme/blocks");
-    const fullPath = path16.resolve(blocksDir, filePath2);
+    const fullPath = path15.resolve(blocksDir, filePath2);
     logger.debug(`Block file ${eventType}: ${filePath2}`);
     if (eventType === "unlink") {
       logger.warn(`Block file deleted: ${filePath2} - Manual cleanup may be required`);
       return;
     }
-    const blockName = path16.basename(filePath2, path16.extname(filePath2));
+    const blockName = path15.basename(filePath2, path15.extname(filePath2));
     this.buildQueue.add(blockName);
     const debounceKey = `block-${blockName}`;
     const existingTimer = this.debounceTimers.get(debounceKey);
@@ -115587,8 +115571,8 @@ class DevCommand {
       const sourceBlocks = await this.blockScanner.scanBlocks(this.configManager.resolvePath(config2.build?.blocksDir || "./theme/blocks"));
       const missingBuilds = [];
       for (const block of sourceBlocks) {
-        const blockBuildDir = path16.join(outputDir, block.name);
-        const blockJsonPath = path16.join(blockBuildDir, "block.json");
+        const blockBuildDir = path15.join(outputDir, block.name);
+        const blockJsonPath = path15.join(blockBuildDir, "block.json");
         if (!fs14.existsSync(blockJsonPath)) {
           missingBuilds.push(block.name);
         }
@@ -115643,7 +115627,7 @@ class DevCommand {
       if (blocks.length === 0) {
         return;
       }
-      const typesPath = path16.join(outputDir, "blocks.d.ts");
+      const typesPath = path15.join(outputDir, "blocks.d.ts");
       await this.typeGenerator.generateDefinitions(blocks, typesPath);
       logger.debug(`\uD83D\uDD27 Updated TypeScript definitions for ${blocks.length} block(s)`);
     } catch (error) {
@@ -115666,7 +115650,7 @@ class DevCommand {
         return;
       }
       logger.info(`\uD83D\uDCC4 Found ${dependentFiles.size} content file(s) that depend on changed blocks`);
-      logger.debug(`Dependent files: ${Array.from(dependentFiles).map((f) => path16.basename(f)).join(", ")}`);
+      logger.debug(`Dependent files: ${Array.from(dependentFiles).map((f) => path15.basename(f)).join(", ")}`);
       const config2 = this.configManager.getConfig();
       const contentDir = this.configManager.resolvePath(config2.paths.mdxOutputDir);
       await this.mdxDependencyTracker.scanMDXDependencies(contentDir);
@@ -115701,7 +115685,7 @@ class DevCommand {
 
 // src/commands/build-templates-command.ts
 import * as fs15 from "fs";
-import * as path17 from "path";
+import * as path16 from "path";
 class BuildTemplatesCommand {
   configManager;
   constructor() {
@@ -115743,8 +115727,8 @@ class BuildTemplatesCommand {
     let errorCount = 0;
     for (let i2 = 0;i2 < templateFiles.length; i2++) {
       const templateFile = templateFiles[i2];
-      const relativePath = path17.relative(templatesDir, templateFile);
-      const templateName = path17.basename(templateFile, ".mdx");
+      const relativePath = path16.relative(templatesDir, templateFile);
+      const templateName = path16.basename(templateFile, ".mdx");
       logger.step(i2 + 1, templateFiles.length, `Building template: ${relativePath}`);
       try {
         await this.buildTemplate(templateFile, templateName, outputDir, renderer);
@@ -115768,15 +115752,15 @@ class BuildTemplatesCommand {
     const cleanContent = this.removeFrontmatter(mdxContent);
     const html5 = await renderer.renderMDXToHTML(cleanContent);
     const cleanHTML = renderer.postProcessHTML(html5);
-    const outputPath = path17.join(outputDir, `${templateName}.html`);
+    const outputPath = path16.join(outputDir, `${templateName}.html`);
     fs15.writeFileSync(outputPath, cleanHTML, "utf8");
-    logger.info(`✓ Generated: ${path17.relative(process.cwd(), outputPath)}`);
+    logger.info(`✓ Generated: ${path16.relative(process.cwd(), outputPath)}`);
   }
   findMDXFiles(dir) {
     const files = [];
     const entries = fs15.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path17.join(dir, entry.name);
+      const fullPath = path16.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...this.findMDXFiles(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".mdx")) {
@@ -115793,7 +115777,7 @@ class BuildTemplatesCommand {
 // package.json
 var package_default = {
   name: "@wordpress-flow/cli",
-  version: "1.0.21",
+  version: "1.0.23",
   type: "module",
   description: "TypeScript-based WordPress block creation system",
   main: "dist/index.js",
@@ -115801,7 +115785,7 @@ var package_default = {
     "wordpress-flow": "./dist/index.js"
   },
   scripts: {
-    build: "bun build ./src/index.ts --outdir ./dist --target node --external esbuild && bun build ./src/build/block-build-worker.ts --outfile ./dist/build/block-build-worker.js --target node --external esbuild"
+    build: "bun build ./src/index.ts --outdir ./dist --target node --external esbuild --external webpack && bun build ./src/build/block-build-worker.ts --outfile ./dist/build/block-build-worker.js --target node --external esbuild --external webpack"
   },
   dependencies: {
     "@babel/core": "^7.28.4",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wordpress-flow/cli",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "type": "module",
   "description": "TypeScript-based WordPress block creation system",
   "main": "dist/index.js",
@@ -8,7 +8,7 @@
     "wordpress-flow": "./dist/index.js"
   },
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target node --external esbuild && bun build ./src/build/block-build-worker.ts --outfile ./dist/build/block-build-worker.js --target node --external esbuild"
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --external esbuild --external webpack && bun build ./src/build/block-build-worker.ts --outfile ./dist/build/block-build-worker.js --target node --external esbuild --external webpack"
   },
   "dependencies": {
     "@babel/core": "^7.28.4",