@wordpress-flow/cli 1.1.3 → 1.2.0

package/dist/index.js

@@ -3337,401 +3337,6 @@ var require_source = __commonJS((exports, module) => {
   module.exports = chalk;
 });
 
-// ../../node_modules/dotenv/package.json
-var require_package = __commonJS((exports, module) => {
-  module.exports = {
-    name: "dotenv",
-    version: "17.2.3",
-    description: "Loads environment variables from .env file",
-    main: "lib/main.js",
-    types: "lib/main.d.ts",
-    exports: {
-      ".": {
-        types: "./lib/main.d.ts",
-        require: "./lib/main.js",
-        default: "./lib/main.js"
-      },
-      "./config": "./config.js",
-      "./config.js": "./config.js",
-      "./lib/env-options": "./lib/env-options.js",
-      "./lib/env-options.js": "./lib/env-options.js",
-      "./lib/cli-options": "./lib/cli-options.js",
-      "./lib/cli-options.js": "./lib/cli-options.js",
-      "./package.json": "./package.json"
-    },
-    scripts: {
-      "dts-check": "tsc --project tests/types/tsconfig.json",
-      lint: "standard",
-      pretest: "npm run lint && npm run dts-check",
-      test: "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
-      "test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
-      prerelease: "npm test",
-      release: "standard-version"
-    },
-    repository: {
-      type: "git",
-      url: "git://github.com/motdotla/dotenv.git"
-    },
-    homepage: "https://github.com/motdotla/dotenv#readme",
-    funding: "https://dotenvx.com",
-    keywords: [
-      "dotenv",
-      "env",
-      ".env",
-      "environment",
-      "variables",
-      "config",
-      "settings"
-    ],
-    readmeFilename: "README.md",
-    license: "BSD-2-Clause",
-    devDependencies: {
-      "@types/node": "^18.11.3",
-      decache: "^4.6.2",
-      sinon: "^14.0.1",
-      standard: "^17.0.0",
-      "standard-version": "^9.5.0",
-      tap: "^19.2.0",
-      typescript: "^4.8.4"
-    },
-    engines: {
-      node: ">=12"
-    },
-    browser: {
-      fs: false
-    }
-  };
-});
-
-// ../../node_modules/dotenv/lib/main.js
-var require_main = __commonJS((exports, module) => {
-  var fs2 = __require("fs");
-  var path2 = __require("path");
-  var os = __require("os");
-  var crypto = __require("crypto");
-  var packageJson = require_package();
-  var version = packageJson.version;
-  var TIPS = [
-    "\uD83D\uDD10 encrypt with Dotenvx: https://dotenvx.com",
-    "\uD83D\uDD10 prevent committing .env to code: https://dotenvx.com/precommit",
-    "\uD83D\uDD10 prevent building .env in docker: https://dotenvx.com/prebuild",
-    "\uD83D\uDCE1 add observability to secrets: https://dotenvx.com/ops",
-    "\uD83D\uDC65 sync secrets across teammates & machines: https://dotenvx.com/ops",
-    "\uD83D\uDDC2️ backup and recover secrets: https://dotenvx.com/ops",
-    "✅ audit secrets and track compliance: https://dotenvx.com/ops",
-    "\uD83D\uDD04 add secrets lifecycle management: https://dotenvx.com/ops",
-    "\uD83D\uDD11 add access controls to secrets: https://dotenvx.com/ops",
-    "\uD83D\uDEE0️  run anywhere with `dotenvx run -- yourcommand`",
-    "⚙️  specify custom .env file path with { path: '/custom/path/.env' }",
-    "⚙️  enable debug logging with { debug: true }",
-    "⚙️  override existing env vars with { override: true }",
-    "⚙️  suppress all logs with { quiet: true }",
-    "⚙️  write to custom object with { processEnv: myObject }",
-    "⚙️  load multiple .env files with { path: ['.env.local', '.env'] }"
-  ];
-  function _getRandomTip() {
-    return TIPS[Math.floor(Math.random() * TIPS.length)];
-  }
-  function parseBoolean(value) {
-    if (typeof value === "string") {
-      return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
-    }
-    return Boolean(value);
-  }
-  function supportsAnsi() {
-    return process.stdout.isTTY;
-  }
-  function dim(text) {
-    return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
-  }
-  var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
-  function parse(src) {
-    const obj = {};
-    let lines = src.toString();
-    lines = lines.replace(/\r\n?/mg, `
-`);
-    let match;
-    while ((match = LINE.exec(lines)) != null) {
-      const key = match[1];
-      let value = match[2] || "";
-      value = value.trim();
-      const maybeQuote = value[0];
-      value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
-      if (maybeQuote === '"') {
-        value = value.replace(/\\n/g, `
-`);
-        value = value.replace(/\\r/g, "\r");
-      }
-      obj[key] = value;
-    }
-    return obj;
-  }
-  function _parseVault(options) {
-    options = options || {};
-    const vaultPath = _vaultPath(options);
-    options.path = vaultPath;
-    const result2 = DotenvModule.configDotenv(options);
-    if (!result2.parsed) {
-      const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
-      err.code = "MISSING_DATA";
-      throw err;
-    }
-    const keys = _dotenvKey(options).split(",");
-    const length = keys.length;
-    let decrypted;
-    for (let i = 0;i < length; i++) {
-      try {
-        const key = keys[i].trim();
-        const attrs = _instructions(result2, key);
-        decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
-        break;
-      } catch (error) {
-        if (i + 1 >= length) {
-          throw error;
-        }
-      }
-    }
-    return DotenvModule.parse(decrypted);
-  }
-  function _warn(message) {
-    console.error(`[dotenv@${version}][WARN] ${message}`);
-  }
-  function _debug(message) {
-    console.log(`[dotenv@${version}][DEBUG] ${message}`);
-  }
-  function _log(message) {
-    console.log(`[dotenv@${version}] ${message}`);
-  }
-  function _dotenvKey(options) {
-    if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
-      return options.DOTENV_KEY;
-    }
-    if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
-      return process.env.DOTENV_KEY;
-    }
-    return "";
-  }
-  function _instructions(result2, dotenvKey) {
-    let uri;
-    try {
-      uri = new URL(dotenvKey);
-    } catch (error) {
-      if (error.code === "ERR_INVALID_URL") {
-        const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
-      }
-      throw error;
-    }
-    const key = uri.password;
-    if (!key) {
-      const err = new Error("INVALID_DOTENV_KEY: Missing key part");
-      err.code = "INVALID_DOTENV_KEY";
-      throw err;
-    }
-    const environment = uri.searchParams.get("environment");
-    if (!environment) {
-      const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
-      err.code = "INVALID_DOTENV_KEY";
-      throw err;
-    }
-    const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
-    const ciphertext = result2.parsed[environmentKey];
-    if (!ciphertext) {
-      const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
-      err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
-      throw err;
-    }
-    return { ciphertext, key };
-  }
-  function _vaultPath(options) {
-    let possibleVaultPath = null;
-    if (options && options.path && options.path.length > 0) {
-      if (Array.isArray(options.path)) {
-        for (const filepath of options.path) {
-          if (fs2.existsSync(filepath)) {
-            possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
-          }
-        }
-      } else {
-        possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
-      }
-    } else {
-      possibleVaultPath = path2.resolve(process.cwd(), ".env.vault");
-    }
-    if (fs2.existsSync(possibleVaultPath)) {
-      return possibleVaultPath;
-    }
-    return null;
-  }
-  function _resolveHome(envPath) {
-    return envPath[0] === "~" ? path2.join(os.homedir(), envPath.slice(1)) : envPath;
-  }
-  function _configVault(options) {
-    const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
-    const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
-    if (debug || !quiet) {
-      _log("Loading env from encrypted .env.vault");
-    }
-    const parsed = DotenvModule._parseVault(options);
-    let processEnv = process.env;
-    if (options && options.processEnv != null) {
-      processEnv = options.processEnv;
-    }
-    DotenvModule.populate(processEnv, parsed, options);
-    return { parsed };
-  }
-  function configDotenv(options) {
-    const dotenvPath = path2.resolve(process.cwd(), ".env");
-    let encoding = "utf8";
-    let processEnv = process.env;
-    if (options && options.processEnv != null) {
-      processEnv = options.processEnv;
-    }
-    let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
-    let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
-    if (options && options.encoding) {
-      encoding = options.encoding;
-    } else {
-      if (debug) {
-        _debug("No encoding is specified. UTF-8 is used by default");
-      }
-    }
-    let optionPaths = [dotenvPath];
-    if (options && options.path) {
-      if (!Array.isArray(options.path)) {
-        optionPaths = [_resolveHome(options.path)];
-      } else {
-        optionPaths = [];
-        for (const filepath of options.path) {
-          optionPaths.push(_resolveHome(filepath));
-        }
-      }
-    }
-    let lastError;
-    const parsedAll = {};
-    for (const path3 of optionPaths) {
-      try {
-        const parsed = DotenvModule.parse(fs2.readFileSync(path3, { encoding }));
-        DotenvModule.populate(parsedAll, parsed, options);
-      } catch (e) {
-        if (debug) {
-          _debug(`Failed to load ${path3} ${e.message}`);
-        }
-        lastError = e;
-      }
-    }
-    const populated = DotenvModule.populate(processEnv, parsedAll, options);
-    debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
-    quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
-    if (debug || !quiet) {
-      const keysCount = Object.keys(populated).length;
-      const shortPaths = [];
-      for (const filePath2 of optionPaths) {
-        try {
-          const relative = path2.relative(process.cwd(), filePath2);
-          shortPaths.push(relative);
-        } catch (e) {
-          if (debug) {
-            _debug(`Failed to load ${filePath2} ${e.message}`);
-          }
-          lastError = e;
-        }
-      }
-      _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
-    }
-    if (lastError) {
-      return { parsed: parsedAll, error: lastError };
-    } else {
-      return { parsed: parsedAll };
-    }
-  }
-  function config(options) {
-    if (_dotenvKey(options).length === 0) {
-      return DotenvModule.configDotenv(options);
-    }
-    const vaultPath = _vaultPath(options);
-    if (!vaultPath) {
-      _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
-      return DotenvModule.configDotenv(options);
-    }
-    return DotenvModule._configVault(options);
-  }
-  function decrypt(encrypted, keyStr) {
-    const key = Buffer.from(keyStr.slice(-64), "hex");
-    let ciphertext = Buffer.from(encrypted, "base64");
-    const nonce = ciphertext.subarray(0, 12);
-    const authTag = ciphertext.subarray(-16);
-    ciphertext = ciphertext.subarray(12, -16);
-    try {
-      const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
-      aesgcm.setAuthTag(authTag);
-      return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
-    } catch (error) {
-      const isRange = error instanceof RangeError;
-      const invalidKeyLength = error.message === "Invalid key length";
-      const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
-      if (isRange || invalidKeyLength) {
-        const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
-      } else if (decryptionFailed) {
-        const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
-        err.code = "DECRYPTION_FAILED";
-        throw err;
-      } else {
-        throw error;
-      }
-    }
-  }
-  function populate(processEnv, parsed, options = {}) {
-    const debug = Boolean(options && options.debug);
-    const override = Boolean(options && options.override);
-    const populated = {};
-    if (typeof parsed !== "object") {
-      const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
-      err.code = "OBJECT_REQUIRED";
-      throw err;
-    }
-    for (const key of Object.keys(parsed)) {
-      if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
-        if (override === true) {
-          processEnv[key] = parsed[key];
-          populated[key] = parsed[key];
-        }
-        if (debug) {
-          if (override === true) {
-            _debug(`"${key}" is already defined and WAS overwritten`);
-          } else {
-            _debug(`"${key}" is already defined and was NOT overwritten`);
-          }
-        }
-      } else {
-        processEnv[key] = parsed[key];
-        populated[key] = parsed[key];
-      }
-    }
-    return populated;
-  }
-  var DotenvModule = {
-    configDotenv,
-    _configVault,
-    _parseVault,
-    config,
-    decrypt,
-    parse,
-    populate
-  };
-  exports.configDotenv = DotenvModule.configDotenv;
-  exports._configVault = DotenvModule._configVault;
-  exports._parseVault = DotenvModule._parseVault;
-  exports.config = DotenvModule.config;
-  exports.decrypt = DotenvModule.decrypt;
-  exports.parse = DotenvModule.parse;
-  exports.populate = DotenvModule.populate;
-  module.exports = DotenvModule;
-});
-
 // ../../node_modules/delayed-stream/lib/delayed_stream.js
 var require_delayed_stream = __commonJS((exports, module) => {
   var Stream = __require("stream").Stream;
@@ -15441,16 +15046,16 @@ var require_parser_cache = __commonJS((exports, module) => {
   var parserCache = createLRU({
     max: 15000
   });
-  function keyFromFields(type, fields, options, config2) {
+  function keyFromFields(type, fields, options, config) {
     const res = [
       type,
       typeof options.nestTables,
       options.nestTables,
       Boolean(options.rowsAsArray),
-      Boolean(options.supportBigNumbers || config2.supportBigNumbers),
-      Boolean(options.bigNumberStrings || config2.bigNumberStrings),
+      Boolean(options.supportBigNumbers || config.supportBigNumbers),
+      Boolean(options.bigNumberStrings || config.bigNumberStrings),
       typeof options.typeCast === "boolean" ? options.typeCast : typeof options.typeCast,
-      options.timezone || config2.timezone,
+      options.timezone || config.timezone,
       Boolean(options.decimalNumbers),
       options.dateStrings
     ];
@@ -15468,13 +15073,13 @@ var require_parser_cache = __commonJS((exports, module) => {
     }
     return JSON.stringify(res, null, 0);
   }
-  function getParser(type, fields, options, config2, compiler) {
-    const key = keyFromFields(type, fields, options, config2);
+  function getParser(type, fields, options, config, compiler) {
+    const key = keyFromFields(type, fields, options, config);
     let parser = parserCache.get(key);
     if (parser) {
       return parser;
     }
-    parser = compiler(fields, options, config2);
+    parser = compiler(fields, options, config);
     parserCache.set(key, parser);
     return parser;
   }
@@ -28611,11 +28216,11 @@ var require_text_parser = __commonJS((exports, module) => {
   for (const t in Types) {
     typeNames[Types[t]] = t;
   }
-  function readCodeFor(type, charset, encodingExpr, config2, options) {
-    const supportBigNumbers = Boolean(options.supportBigNumbers || config2.supportBigNumbers);
-    const bigNumberStrings = Boolean(options.bigNumberStrings || config2.bigNumberStrings);
-    const timezone = options.timezone || config2.timezone;
-    const dateStrings = options.dateStrings || config2.dateStrings;
+  function readCodeFor(type, charset, encodingExpr, config, options) {
+    const supportBigNumbers = Boolean(options.supportBigNumbers || config.supportBigNumbers);
+    const bigNumberStrings = Boolean(options.bigNumberStrings || config.bigNumberStrings);
+    const timezone = options.timezone || config.timezone;
+    const dateStrings = options.dateStrings || config.dateStrings;
     switch (type) {
       case Types.TINY:
       case Types.SHORT:
@@ -28635,7 +28240,7 @@ var require_text_parser = __commonJS((exports, module) => {
         return "packet.readLengthCodedNumber()";
       case Types.DECIMAL:
       case Types.NEWDECIMAL:
-        if (config2.decimalNumbers) {
+        if (config.decimalNumbers) {
           return "packet.parseLengthCodedFloat()";
         }
         return 'packet.readLengthCodedString("ascii")';
@@ -28657,7 +28262,7 @@ var require_text_parser = __commonJS((exports, module) => {
       case Types.VECTOR:
         return "packet.parseVector()";
       case Types.JSON:
-        return config2.jsonStrings ? 'packet.readLengthCodedString("utf8")' : 'JSON.parse(packet.readLengthCodedString("utf8"))';
+        return config.jsonStrings ? 'packet.readLengthCodedString("utf8")' : 'JSON.parse(packet.readLengthCodedString("utf8"))';
       default:
         if (charset === Charsets.BINARY) {
           return "packet.readLengthCodedBuffer()";
@@ -28665,9 +28270,9 @@ var require_text_parser = __commonJS((exports, module) => {
         return `packet.readLengthCodedString(${encodingExpr})`;
     }
   }
-  function compile(fields, options, config2) {
-    if (typeof config2.typeCast === "function" && typeof options.typeCast !== "function") {
-      options.typeCast = config2.typeCast;
+  function compile(fields, options, config) {
+    if (typeof config.typeCast === "function" && typeof options.typeCast !== "function") {
+      options.typeCast = config.typeCast;
     }
     function wrap(field, _this) {
       return {
@@ -28738,7 +28343,7 @@ var require_text_parser = __commonJS((exports, module) => {
         parserFn(`${lvalue} = packet.readLengthCodedBuffer();`);
       } else {
         const encodingExpr = `fields[${i}].encoding`;
-        const readCode = readCodeFor(fields[i].columnType, fields[i].characterSet, encodingExpr, config2, options);
+        const readCode = readCodeFor(fields[i].columnType, fields[i].characterSet, encodingExpr, config, options);
         if (typeof options.typeCast === "function") {
           parserFn(`${lvalue} = options.typeCast(this.wrap${i}, function() { return ${readCode} });`);
         } else {
@@ -28749,7 +28354,7 @@ var require_text_parser = __commonJS((exports, module) => {
     parserFn("return result;");
     parserFn("}");
     parserFn("};")("})()");
-    if (config2.debug) {
+    if (config.debug) {
       helpers.printDebugWithCode("Compiled text protocol row parser", parserFn.toString());
     }
     if (typeof options.typeCast === "function") {
@@ -28757,8 +28362,8 @@ var require_text_parser = __commonJS((exports, module) => {
     }
     return parserFn.toFunction();
   }
-  function getTextParser(fields, options, config2) {
-    return parserCache.getParser("text", fields, options, config2, compile);
+  function getTextParser(fields, options, config) {
+    return parserCache.getParser("text", fields, options, config, compile);
   }
   module.exports = getTextParser;
 });
@@ -28772,11 +28377,11 @@ var require_static_text_parser = __commonJS((exports, module) => {
   for (const t in Types) {
     typeNames[Types[t]] = t;
   }
-  function readField({ packet, type, charset, encoding, config: config2, options }) {
-    const supportBigNumbers = Boolean(options.supportBigNumbers || config2.supportBigNumbers);
-    const bigNumberStrings = Boolean(options.bigNumberStrings || config2.bigNumberStrings);
-    const timezone = options.timezone || config2.timezone;
-    const dateStrings = options.dateStrings || config2.dateStrings;
+  function readField({ packet, type, charset, encoding, config, options }) {
+    const supportBigNumbers = Boolean(options.supportBigNumbers || config.supportBigNumbers);
+    const bigNumberStrings = Boolean(options.bigNumberStrings || config.bigNumberStrings);
+    const timezone = options.timezone || config.timezone;
+    const dateStrings = options.dateStrings || config.dateStrings;
     switch (type) {
       case Types.TINY:
       case Types.SHORT:
@@ -28795,7 +28400,7 @@ var require_static_text_parser = __commonJS((exports, module) => {
       case Types.NULL:
       case Types.DECIMAL:
       case Types.NEWDECIMAL:
-        if (config2.decimalNumbers) {
+        if (config.decimalNumbers) {
           return packet.parseLengthCodedFloat();
         }
         return packet.readLengthCodedString("ascii");
@@ -28817,7 +28422,7 @@ var require_static_text_parser = __commonJS((exports, module) => {
       case Types.VECTOR:
         return packet.parseVector();
       case Types.JSON:
-        return config2.jsonStrings ? packet.readLengthCodedString("utf8") : JSON.parse(packet.readLengthCodedString("utf8"));
+        return config.jsonStrings ? packet.readLengthCodedString("utf8") : JSON.parse(packet.readLengthCodedString("utf8"));
       default:
         if (charset === Charsets.BINARY) {
           return packet.readLengthCodedBuffer();
@@ -28846,19 +28451,19 @@ var require_static_text_parser = __commonJS((exports, module) => {
       }
     };
   }
-  function getTextParser(_fields, _options, config2) {
+  function getTextParser(_fields, _options, config) {
     return {
       next(packet, fields, options) {
         const result2 = options.rowsAsArray ? [] : {};
         for (let i = 0;i < fields.length; i++) {
           const field = fields[i];
-          const typeCast = options.typeCast ? options.typeCast : config2.typeCast;
+          const typeCast = options.typeCast ? options.typeCast : config.typeCast;
           const next = () => readField({
             packet,
             type: field.columnType,
             encoding: field.encoding,
             charset: field.characterSet,
-            config: config2,
+            config,
             options
           });
           let value;
@@ -29216,11 +28821,11 @@ var require_binary_parser = __commonJS((exports, module) => {
   for (const t in Types) {
     typeNames[Types[t]] = t;
   }
-  function readCodeFor(field, config2, options, fieldNum) {
-    const supportBigNumbers = Boolean(options.supportBigNumbers || config2.supportBigNumbers);
-    const bigNumberStrings = Boolean(options.bigNumberStrings || config2.bigNumberStrings);
-    const timezone = options.timezone || config2.timezone;
-    const dateStrings = options.dateStrings || config2.dateStrings;
+  function readCodeFor(field, config, options, fieldNum) {
+    const supportBigNumbers = Boolean(options.supportBigNumbers || config.supportBigNumbers);
+    const bigNumberStrings = Boolean(options.bigNumberStrings || config.bigNumberStrings);
+    const timezone = options.timezone || config.timezone;
+    const dateStrings = options.dateStrings || config.dateStrings;
     const unsigned = field.flags & FieldFlags.UNSIGNED;
     switch (field.columnType) {
       case Types.TINY:
@@ -29250,7 +28855,7 @@ var require_binary_parser = __commonJS((exports, module) => {
         return "packet.readTimeString()";
       case Types.DECIMAL:
       case Types.NEWDECIMAL:
-        if (config2.decimalNumbers) {
+        if (config.decimalNumbers) {
           return "packet.parseLengthCodedFloat();";
         }
         return 'packet.readLengthCodedString("ascii");';
@@ -29259,7 +28864,7 @@ var require_binary_parser = __commonJS((exports, module) => {
       case Types.VECTOR:
         return "packet.parseVector()";
       case Types.JSON:
-        return config2.jsonStrings ? 'packet.readLengthCodedString("utf8")' : 'JSON.parse(packet.readLengthCodedString("utf8"));';
+        return config.jsonStrings ? 'packet.readLengthCodedString("utf8")' : 'JSON.parse(packet.readLengthCodedString("utf8"));';
       case Types.LONGLONG:
         if (!supportBigNumbers) {
           return unsigned ? "packet.readInt64JSNumber();" : "packet.readSInt64JSNumber();";
@@ -29275,7 +28880,7 @@ var require_binary_parser = __commonJS((exports, module) => {
         return `packet.readLengthCodedString(fields[${fieldNum}].encoding)`;
     }
   }
-  function compile(fields, options, config2) {
+  function compile(fields, options, config) {
     const parserFn = genFunc();
     const nullBitmapLength = Math.floor((fields.length + 7 + 2) / 8);
     function wrap(field, packet) {
@@ -29319,8 +28924,8 @@ var require_binary_parser = __commonJS((exports, module) => {
     } else {
       parserFn("const result = {};");
     }
-    if (typeof config2.typeCast === "function" && typeof options.typeCast !== "function") {
-      options.typeCast = config2.typeCast;
+    if (typeof config.typeCast === "function" && typeof options.typeCast !== "function") {
+      options.typeCast = config.typeCast;
     }
     parserFn("packet.readInt8();");
     for (let i = 0;i < nullBitmapLength; ++i) {
@@ -29352,7 +28957,7 @@ var require_binary_parser = __commonJS((exports, module) => {
       } else {
         const fieldWrapperVar = `fieldWrapper${i}`;
         parserFn(`const ${fieldWrapperVar} = wrap(fields[${i}], packet);`);
-        const readCode = readCodeFor(fields[i], config2, options, i);
+        const readCode = readCodeFor(fields[i], config, options, i);
         if (typeof options.typeCast === "function") {
           parserFn(`${lvalue} = options.typeCast(${fieldWrapperVar}, function() { return ${readCode} });`);
         } else {
@@ -29369,13 +28974,13 @@ var require_binary_parser = __commonJS((exports, module) => {
     parserFn("return result;");
     parserFn("}");
     parserFn("};")("})()");
-    if (config2.debug) {
+    if (config.debug) {
       helpers.printDebugWithCode("Compiled binary protocol row parser", parserFn.toString());
     }
     return parserFn.toFunction({ wrap });
   }
-  function getBinaryParser(fields, options, config2) {
-    return parserCache.getParser("binary", fields, options, config2, compile);
+  function getBinaryParser(fields, options, config) {
+    return parserCache.getParser("binary", fields, options, config, compile);
   }
   module.exports = getBinaryParser;
 });
@@ -29390,12 +28995,12 @@ var require_static_binary_parser = __commonJS((exports, module) => {
   for (const t in Types) {
     typeNames[Types[t]] = t;
   }
-  function getBinaryParser(fields, _options, config2) {
-    function readCode(field, config3, options, fieldNum, packet) {
-      const supportBigNumbers = Boolean(options.supportBigNumbers || config3.supportBigNumbers);
-      const bigNumberStrings = Boolean(options.bigNumberStrings || config3.bigNumberStrings);
-      const timezone = options.timezone || config3.timezone;
-      const dateStrings = options.dateStrings || config3.dateStrings;
+  function getBinaryParser(fields, _options, config) {
+    function readCode(field, config2, options, fieldNum, packet) {
+      const supportBigNumbers = Boolean(options.supportBigNumbers || config2.supportBigNumbers);
+      const bigNumberStrings = Boolean(options.bigNumberStrings || config2.bigNumberStrings);
+      const timezone = options.timezone || config2.timezone;
+      const dateStrings = options.dateStrings || config2.dateStrings;
       const unsigned = field.flags & FieldFlags.UNSIGNED;
       switch (field.columnType) {
         case Types.TINY:
@@ -29422,13 +29027,13 @@ var require_static_binary_parser = __commonJS((exports, module) => {
           return packet.readTimeString();
         case Types.DECIMAL:
         case Types.NEWDECIMAL:
-          return config3.decimalNumbers ? packet.parseLengthCodedFloat() : packet.readLengthCodedString("ascii");
+          return config2.decimalNumbers ? packet.parseLengthCodedFloat() : packet.readLengthCodedString("ascii");
         case Types.GEOMETRY:
           return packet.parseGeometryValue();
         case Types.VECTOR:
           return packet.parseVector();
         case Types.JSON:
-          return config3.jsonStrings ? packet.readLengthCodedString("utf8") : JSON.parse(packet.readLengthCodedString("utf8"));
+          return config2.jsonStrings ? packet.readLengthCodedString("utf8") : JSON.parse(packet.readLengthCodedString("utf8"));
         case Types.LONGLONG:
           if (!supportBigNumbers)
             return unsigned ? packet.readInt64JSNumber() : packet.readSInt64JSNumber();
@@ -29451,14 +29056,14 @@ var require_static_binary_parser = __commonJS((exports, module) => {
         let nullByteIndex = 0;
         for (let i = 0;i < fields2.length; i++) {
           const field = fields2[i];
-          const typeCast = options.typeCast !== undefined ? options.typeCast : config2.typeCast;
+          const typeCast = options.typeCast !== undefined ? options.typeCast : config.typeCast;
           let value;
           if (nullBitmaskBytes[nullByteIndex] & currentFieldNullBit) {
             value = null;
           } else if (options.typeCast === false) {
             value = packet.readLengthCodedBuffer();
           } else {
-            const next = () => readCode(field, config2, options, i, packet);
+            const next = () => readCode(field, config, options, i, packet);
             value = typeof typeCast === "function" ? typeCast({
               type: typeNames[field.columnType],
               length: field.columnLength,
@@ -30078,7 +29683,7 @@ var require_commands2 = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/mysql2/package.json
-var require_package2 = __commonJS((exports, module) => {
+var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "mysql2",
     version: "3.15.3",
@@ -33302,7 +32907,7 @@ var require_connection_config = __commonJS((exports, module) => {
   var { URL: URL2 } = __require("url");
   var ClientConstants = require_client();
   var Charsets = require_charsets();
-  var { version } = require_package2();
+  var { version } = require_package();
   var SSLProfiles = null;
   var validOptions = {
     authPlugins: 1,
@@ -34569,21 +34174,21 @@ var require_named_placeholders = __commonJS((exports, module) => {
     }
     return [query];
   }
-  function createCompiler(config2) {
-    if (!config2)
-      config2 = {};
-    if (!config2.placeholder) {
-      config2.placeholder = "?";
+  function createCompiler(config) {
+    if (!config)
+      config = {};
+    if (!config.placeholder) {
+      config.placeholder = "?";
     }
     let ncache = 100;
     let cache;
-    if (typeof config2.cache === "number") {
-      ncache = config2.cache;
+    if (typeof config.cache === "number") {
+      ncache = config.cache;
     }
-    if (typeof config2.cache === "object") {
-      cache = config2.cache;
+    if (typeof config.cache === "object") {
+      cache = config.cache;
     }
-    if (config2.cache !== false && !cache) {
+    if (config.cache !== false && !cache) {
       cache = new (require_lru_cache())({ max: ncache });
     }
     function toArrayParams(tree, params) {
@@ -34612,17 +34217,17 @@ var require_named_placeholders = __commonJS((exports, module) => {
       let unnamed = noTailingSemicolon(tree[0][0]);
       for (let i = 1;i < tree[0].length; ++i) {
         if (tree[0][i - 1].slice(-1) == ":") {
-          unnamed += config2.placeholder;
+          unnamed += config.placeholder;
         }
-        unnamed += config2.placeholder;
+        unnamed += config.placeholder;
         unnamed += noTailingSemicolon(tree[0][i]);
       }
       const last = tree[0][tree[0].length - 1];
       if (tree[0].length == tree[1].length) {
         if (last.slice(-1) == ":") {
-          unnamed += config2.placeholder;
+          unnamed += config.placeholder;
         }
-        unnamed += config2.placeholder;
+        unnamed += config.placeholder;
       }
       return [unnamed, tree[1]];
     }
@@ -35344,10 +34949,10 @@ var require_connection = __commonJS((exports, module) => {
       this.addCommand = this._addCommandClosedState;
       return quitCmd;
     }
-    static createQuery(sql, values, cb, config2) {
+    static createQuery(sql, values, cb, config) {
       let options = {
-        rowsAsArray: config2.rowsAsArray,
-        infileStreamFactory: config2.infileStreamFactory
+        rowsAsArray: config.rowsAsArray,
+        infileStreamFactory: config.infileStreamFactory
       };
       if (typeof sql === "object") {
         options = {
@@ -36178,13 +35783,13 @@ var require_pool_cluster = __commonJS((exports, module) => {
   }
 
   class PoolCluster extends EventEmitter2 {
-    constructor(config2) {
+    constructor(config) {
       super();
-      config2 = config2 || {};
-      this._canRetry = typeof config2.canRetry === "undefined" ? true : config2.canRetry;
-      this._removeNodeErrorCount = config2.removeNodeErrorCount || 5;
-      this._restoreNodeTimeout = config2.restoreNodeTimeout || 0;
-      this._defaultSelector = config2.defaultSelector || "RR";
+      config = config || {};
+      this._canRetry = typeof config.canRetry === "undefined" ? true : config.canRetry;
+      this._removeNodeErrorCount = config.removeNodeErrorCount || 5;
+      this._restoreNodeTimeout = config.restoreNodeTimeout || 0;
+      this._defaultSelector = config.defaultSelector || "RR";
       this._closed = false;
       this._lastId = 0;
       this._nodes = {};
@@ -36205,16 +35810,16 @@ var require_pool_cluster = __commonJS((exports, module) => {
       }
       return this._namespaces[key];
     }
-    add(id, config2) {
+    add(id, config) {
       if (typeof id === "object") {
-        config2 = id;
+        config = id;
         id = `CLUSTER::${++this._lastId}`;
       }
       if (typeof this._nodes[id] === "undefined") {
         this._nodes[id] = {
           id,
           errorCount: 0,
-          pool: new Pool({ config: new PoolConfig(config2) }),
+          pool: new Pool({ config: new PoolConfig(config) }),
           _offlineUntil: 0
         };
         this._serviceableNodeIds.push(id);
@@ -36364,8 +35969,8 @@ var require_create_connection = __commonJS((exports, module) => {
 var require_create_pool = __commonJS((exports, module) => {
   var Pool = require_pool3();
   var PoolConfig = require_pool_config();
-  function createPool(config2) {
-    return new Pool({ config: new PoolConfig(config2) });
+  function createPool(config) {
+    return new Pool({ config: new PoolConfig(config) });
   }
   module.exports = createPool;
 });
@@ -36373,8 +35978,8 @@ var require_create_pool = __commonJS((exports, module) => {
 // ../../node_modules/mysql2/lib/create_pool_cluster.js
 var require_create_pool_cluster = __commonJS((exports, module) => {
   var PoolCluster = require_pool_cluster();
-  function createPoolCluster(config2) {
-    return new PoolCluster(config2);
+  function createPoolCluster(config) {
+    return new PoolCluster(config);
   }
   module.exports = createPoolCluster;
 });
@@ -36898,27 +36503,27 @@ var require_react_development = __commonJS((exports, module) => {
       {
         didWarnAboutStringRefs = {};
       }
-      function hasValidRef(config2) {
+      function hasValidRef(config) {
         {
-          if (hasOwnProperty2.call(config2, "ref")) {
-            var getter = Object.getOwnPropertyDescriptor(config2, "ref").get;
+          if (hasOwnProperty2.call(config, "ref")) {
+            var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
             if (getter && getter.isReactWarning) {
               return false;
             }
           }
         }
-        return config2.ref !== undefined;
+        return config.ref !== undefined;
       }
-      function hasValidKey(config2) {
+      function hasValidKey(config) {
         {
-          if (hasOwnProperty2.call(config2, "key")) {
-            var getter = Object.getOwnPropertyDescriptor(config2, "key").get;
+          if (hasOwnProperty2.call(config, "key")) {
+            var getter = Object.getOwnPropertyDescriptor(config, "key").get;
             if (getter && getter.isReactWarning) {
               return false;
             }
           }
         }
-        return config2.key !== undefined;
+        return config.key !== undefined;
       }
       function defineKeyPropWarningGetter(props, displayName) {
         var warnAboutAccessingKey = function() {
@@ -36950,12 +36555,12 @@ var require_react_development = __commonJS((exports, module) => {
           configurable: true
         });
       }
-      function warnIfStringRefCannotBeAutoConverted(config2) {
+      function warnIfStringRefCannotBeAutoConverted(config) {
         {
-          if (typeof config2.ref === "string" && ReactCurrentOwner.current && config2.__self && ReactCurrentOwner.current.stateNode !== config2.__self) {
+          if (typeof config.ref === "string" && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
             var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
             if (!didWarnAboutStringRefs[componentName]) {
-              error('Component "%s" contains the string ref "%s". ' + "Support for string refs will be removed in a future major release. " + "This case cannot be automatically converted to an arrow function. " + "We ask you to manually fix this case by using useRef() or createRef() instead. " + "Learn more about using refs safely here: " + "https://reactjs.org/link/strict-mode-string-ref", componentName, config2.ref);
+              error('Component "%s" contains the string ref "%s". ' + "Support for string refs will be removed in a future major release. " + "This case cannot be automatically converted to an arrow function. " + "We ask you to manually fix this case by using useRef() or createRef() instead. " + "Learn more about using refs safely here: " + "https://reactjs.org/link/strict-mode-string-ref", componentName, config.ref);
               didWarnAboutStringRefs[componentName] = true;
             }
           }
@@ -36997,31 +36602,31 @@ var require_react_development = __commonJS((exports, module) => {
         }
         return element;
       };
-      function createElement(type, config2, children) {
+      function createElement(type, config, children) {
         var propName;
         var props = {};
         var key = null;
         var ref = null;
         var self2 = null;
         var source = null;
-        if (config2 != null) {
-          if (hasValidRef(config2)) {
-            ref = config2.ref;
+        if (config != null) {
+          if (hasValidRef(config)) {
+            ref = config.ref;
             {
-              warnIfStringRefCannotBeAutoConverted(config2);
+              warnIfStringRefCannotBeAutoConverted(config);
             }
           }
-          if (hasValidKey(config2)) {
+          if (hasValidKey(config)) {
             {
-              checkKeyStringCoercion(config2.key);
+              checkKeyStringCoercion(config.key);
             }
-            key = "" + config2.key;
+            key = "" + config.key;
           }
-          self2 = config2.__self === undefined ? null : config2.__self;
-          source = config2.__source === undefined ? null : config2.__source;
-          for (propName in config2) {
-            if (hasOwnProperty2.call(config2, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
-              props[propName] = config2[propName];
+          self2 = config.__self === undefined ? null : config.__self;
+          source = config.__source === undefined ? null : config.__source;
+          for (propName in config) {
+            if (hasOwnProperty2.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+              props[propName] = config[propName];
             }
           }
         }
@@ -37065,7 +36670,7 @@ var require_react_development = __commonJS((exports, module) => {
         var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
         return newElement;
       }
-      function cloneElement(element, config2, children) {
+      function cloneElement(element, config, children) {
         if (element === null || element === undefined) {
           throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
         }
@@ -37076,27 +36681,27 @@ var require_react_development = __commonJS((exports, module) => {
         var self2 = element._self;
         var source = element._source;
         var owner = element._owner;
-        if (config2 != null) {
-          if (hasValidRef(config2)) {
-            ref = config2.ref;
+        if (config != null) {
+          if (hasValidRef(config)) {
+            ref = config.ref;
             owner = ReactCurrentOwner.current;
           }
-          if (hasValidKey(config2)) {
+          if (hasValidKey(config)) {
             {
-              checkKeyStringCoercion(config2.key);
+              checkKeyStringCoercion(config.key);
             }
-            key = "" + config2.key;
+            key = "" + config.key;
           }
           var defaultProps;
           if (element.type && element.type.defaultProps) {
             defaultProps = element.type.defaultProps;
           }
-          for (propName in config2) {
-            if (hasOwnProperty2.call(config2, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
-              if (config2[propName] === undefined && defaultProps !== undefined) {
+          for (propName in config) {
+            if (hasOwnProperty2.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+              if (config[propName] === undefined && defaultProps !== undefined) {
                 props[propName] = defaultProps[propName];
               } else {
-                props[propName] = config2[propName];
+                props[propName] = config[propName];
               }
             }
           }
@@ -55429,34 +55034,34 @@ var require_react_jsx_runtime_development = __commonJS((exports) => {
       {
         didWarnAboutStringRefs = {};
       }
-      function hasValidRef(config2) {
+      function hasValidRef(config) {
         {
-          if (hasOwnProperty4.call(config2, "ref")) {
-            var getter = Object.getOwnPropertyDescriptor(config2, "ref").get;
+          if (hasOwnProperty4.call(config, "ref")) {
+            var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
             if (getter && getter.isReactWarning) {
               return false;
             }
           }
         }
-        return config2.ref !== undefined;
+        return config.ref !== undefined;
       }
-      function hasValidKey(config2) {
+      function hasValidKey(config) {
         {
-          if (hasOwnProperty4.call(config2, "key")) {
-            var getter = Object.getOwnPropertyDescriptor(config2, "key").get;
+          if (hasOwnProperty4.call(config, "key")) {
+            var getter = Object.getOwnPropertyDescriptor(config, "key").get;
             if (getter && getter.isReactWarning) {
               return false;
             }
           }
         }
-        return config2.key !== undefined;
+        return config.key !== undefined;
       }
-      function warnIfStringRefCannotBeAutoConverted(config2, self2) {
+      function warnIfStringRefCannotBeAutoConverted(config, self2) {
         {
-          if (typeof config2.ref === "string" && ReactCurrentOwner.current && self2 && ReactCurrentOwner.current.stateNode !== self2) {
+          if (typeof config.ref === "string" && ReactCurrentOwner.current && self2 && ReactCurrentOwner.current.stateNode !== self2) {
             var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
             if (!didWarnAboutStringRefs[componentName]) {
-              error('Component "%s" contains the string ref "%s". ' + "Support for string refs will be removed in a future major release. " + "This case cannot be automatically converted to an arrow function. " + "We ask you to manually fix this case by using useRef() or createRef() instead. " + "Learn more about using refs safely here: " + "https://reactjs.org/link/strict-mode-string-ref", getComponentNameFromType(ReactCurrentOwner.current.type), config2.ref);
+              error('Component "%s" contains the string ref "%s". ' + "Support for string refs will be removed in a future major release. " + "This case cannot be automatically converted to an arrow function. " + "We ask you to manually fix this case by using useRef() or createRef() instead. " + "Learn more about using refs safely here: " + "https://reactjs.org/link/strict-mode-string-ref", getComponentNameFromType(ReactCurrentOwner.current.type), config.ref);
               didWarnAboutStringRefs[componentName] = true;
             }
           }
@@ -55528,7 +55133,7 @@ var require_react_jsx_runtime_development = __commonJS((exports) => {
         }
         return element2;
       };
-      function jsxDEV(type, config2, maybeKey, source, self2) {
+      function jsxDEV(type, config, maybeKey, source, self2) {
         {
           var propName;
           var props = {};
@@ -55540,19 +55145,19 @@ var require_react_jsx_runtime_development = __commonJS((exports) => {
             }
             key = "" + maybeKey;
           }
-          if (hasValidKey(config2)) {
+          if (hasValidKey(config)) {
             {
-              checkKeyStringCoercion(config2.key);
+              checkKeyStringCoercion(config.key);
             }
-            key = "" + config2.key;
+            key = "" + config.key;
           }
-          if (hasValidRef(config2)) {
-            ref2 = config2.ref;
-            warnIfStringRefCannotBeAutoConverted(config2, self2);
+          if (hasValidRef(config)) {
+            ref2 = config.ref;
+            warnIfStringRefCannotBeAutoConverted(config, self2);
           }
-          for (propName in config2) {
-            if (hasOwnProperty4.call(config2, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
-              props[propName] = config2[propName];
+          for (propName in config) {
+            if (hasOwnProperty4.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+              props[propName] = config[propName];
             }
           }
           if (type && type.defaultProps) {
@@ -55871,13 +55476,13 @@ __export(exports_system_block, {
   WP: () => WP,
   Shortcode: () => Shortcode
 });
-function systemBlock(config2) {
+function systemBlock(config) {
   const SystemBlockComponent = (props) => {
     const { children, ...attributes } = props;
-    const content4 = config2.render(props);
-    return createFSEWrapper(config2.name, attributes, content4 || children);
+    const content4 = config.render(props);
+    return createFSEWrapper(config.name, attributes, content4 || children);
   };
-  SystemBlockComponent.displayName = `SystemBlock(${config2.name})`;
+  SystemBlockComponent.displayName = `SystemBlock(${config.name})`;
   return SystemBlockComponent;
 }
 var import_react2, WP = ({
@@ -81290,21 +80895,65 @@ Conflict Resolution:`));
   }
 }
 // src/config/config-manager.ts
-var dotenv = __toESM(require_main(), 1);
 import * as fs2 from "fs";
 import * as path2 from "path";
+var DEFAULTS = {
+  paths: {
+    theme: "./theme",
+    content: "./content",
+    plugins: "./plugins"
+  },
+  sync: {
+    excludePostTypes: [],
+    includedPostStatuses: ["publish", "draft"]
+  },
+  dev: {
+    port: 8888,
+    databasePort: 3306,
+    phpVersion: "8.2",
+    wordpressVersion: "latest",
+    plugins: []
+  }
+};
 
 class ConfigManager {
   static instance;
   config = null;
+  rawConfig = null;
   configPath;
   configDir;
   envPath;
+  runtimeDatabase = null;
   constructor() {
     this.configPath = path2.join(process.cwd(), "wordpress-flow.config.json");
     this.configDir = path2.dirname(this.configPath);
     this.envPath = path2.join(this.configDir, ".env");
-    dotenv.config({ path: this.envPath });
+    this.loadEnvFile();
+  }
+  loadEnvFile() {
+    if (!fs2.existsSync(this.envPath))
+      return;
+    try {
+      const content2 = fs2.readFileSync(this.envPath, "utf8");
+      const lines = content2.split(`
+`);
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+          continue;
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex === -1)
+          continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        let value = trimmed.slice(eqIndex + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        if (process.env[key] === undefined) {
+          process.env[key] = value;
+        }
+      }
+    } catch {}
   }
   static getInstance() {
     if (!ConfigManager.instance) {
@@ -81316,24 +80965,144 @@ class ConfigManager {
     if (this.config) {
       return this.config;
     }
-    if (!fs2.existsSync(this.configPath)) {
-      throw new Error(`Configuration file not found at ${this.configPath}. Please run the setup wizard first.`);
+    let rawConfig = {};
+    if (fs2.existsSync(this.configPath)) {
+      try {
+        const configContent = fs2.readFileSync(this.configPath, "utf8");
+        rawConfig = JSON.parse(configContent);
+        if (this.isLegacyConfig(rawConfig)) {
+          rawConfig = this.migrateLegacyConfig(rawConfig);
+        }
+      } catch (error) {
+        throw new Error(`Failed to load configuration: ${error.message}`);
+      }
     }
-    try {
-      const configContent = fs2.readFileSync(this.configPath, "utf8");
-      const config2 = JSON.parse(configContent);
-      this.config = this.mergeWithEnvCredentials(config2);
-      return this.config;
-    } catch (error) {
-      throw new Error(`Failed to load configuration: ${error.message}`);
+    this.rawConfig = rawConfig;
+    this.config = this.resolveConfig(rawConfig);
+    return this.config;
+  }
+  isLegacyConfig(config) {
+    return config.wordpress !== undefined || config.env !== undefined || config.build !== undefined;
+  }
+  migrateLegacyConfig(legacy) {
+    const newConfig = {};
+    if (legacy.env?.themeDir || legacy.paths?.mdxOutputDir || legacy.env?.pluginsDir) {
+      newConfig.paths = {
+        theme: legacy.env?.themeDir || legacy.build?.blocksDir?.replace("/blocks", "") || DEFAULTS.paths.theme,
+        content: legacy.paths?.mdxOutputDir || DEFAULTS.paths.content,
+        plugins: legacy.env?.pluginsDir || DEFAULTS.paths.plugins
+      };
+    }
+    if (legacy.sync?.excludePostTypes || legacy.sync?.includedPostStatuses) {
+      newConfig.sync = {
+        excludePostTypes: legacy.sync?.excludePostTypes,
+        includedPostStatuses: legacy.sync?.includedPostStatuses
+      };
+    }
+    if (legacy.env) {
+      newConfig.dev = {
+        port: legacy.env.port,
+        databasePort: legacy.env.databasePort,
+        phpVersion: legacy.env.phpVersion,
+        wordpressVersion: legacy.env.wordpressVersion,
+        plugins: legacy.env.plugins,
+        sqlDump: legacy.env.sqlDump
+      };
     }
+    return newConfig;
+  }
+  resolveConfig(raw) {
+    const theme = raw.paths?.theme || DEFAULTS.paths.theme;
+    const content2 = raw.paths?.content || DEFAULTS.paths.content;
+    const plugins = raw.paths?.plugins || DEFAULTS.paths.plugins;
+    return {
+      paths: {
+        theme,
+        content: content2,
+        plugins,
+        blocks: `${theme}/blocks`,
+        dist: `${theme}/dist`,
+        scripts: `${theme}/scripts`,
+        templates: `${content2}/templates`,
+        templateParts: `${content2}/parts`,
+        templatesOutput: `${theme}/templates`,
+        partsOutput: `${theme}/parts`
+      },
+      sync: {
+        excludePostTypes: raw.sync?.excludePostTypes || DEFAULTS.sync.excludePostTypes,
+        includedPostStatuses: raw.sync?.includedPostStatuses || DEFAULTS.sync.includedPostStatuses
+      },
+      dev: {
+        port: raw.dev?.port || DEFAULTS.dev.port,
+        databasePort: raw.dev?.databasePort || DEFAULTS.dev.databasePort,
+        phpVersion: raw.dev?.phpVersion || DEFAULTS.dev.phpVersion,
+        wordpressVersion: raw.dev?.wordpressVersion || DEFAULTS.dev.wordpressVersion,
+        plugins: raw.dev?.plugins || DEFAULTS.dev.plugins,
+        sqlDump: raw.dev?.sqlDump
+      },
+      database: this.runtimeDatabase || undefined
+    };
   }
-  async saveConfig(config2) {
-    const publicConfig = this.stripSensitiveData(config2);
-    const envVars = this.extractEnvVars(config2);
-    fs2.writeFileSync(this.configPath, JSON.stringify(publicConfig, null, 2));
-    await this.updateEnvFile(envVars);
-    this.config = config2;
+  async saveConfig(config) {
+    const minimalConfig = this.stripDefaults(config);
+    fs2.writeFileSync(this.configPath, JSON.stringify(minimalConfig, null, 2));
+    this.rawConfig = config;
+    this.config = this.resolveConfig(config);
+  }
+  stripDefaults(config) {
+    const result2 = {};
+    if (config.paths) {
+      const paths = {};
+      if (config.paths.theme && config.paths.theme !== DEFAULTS.paths.theme) {
+        paths.theme = config.paths.theme;
+      }
+      if (config.paths.content && config.paths.content !== DEFAULTS.paths.content) {
+        paths.content = config.paths.content;
+      }
+      if (config.paths.plugins && config.paths.plugins !== DEFAULTS.paths.plugins) {
+        paths.plugins = config.paths.plugins;
+      }
+      if (Object.keys(paths).length > 0) {
+        result2.paths = paths;
+      }
+    }
+    if (config.sync) {
+      const sync = {};
+      if (config.sync.excludePostTypes && config.sync.excludePostTypes.length > 0) {
+        sync.excludePostTypes = config.sync.excludePostTypes;
+      }
+      if (config.sync.includedPostStatuses && JSON.stringify(config.sync.includedPostStatuses) !== JSON.stringify(DEFAULTS.sync.includedPostStatuses)) {
+        sync.includedPostStatuses = config.sync.includedPostStatuses;
+      }
+      if (Object.keys(sync).length > 0) {
+        result2.sync = sync;
+      }
+    }
+    if (config.dev) {
+      const dev = {};
+      if (config.dev.port && config.dev.port !== DEFAULTS.dev.port) {
+        dev.port = config.dev.port;
+      }
+      if (config.dev.databasePort && config.dev.databasePort !== DEFAULTS.dev.databasePort) {
+        dev.databasePort = config.dev.databasePort;
+      }
+      if (config.dev.phpVersion && config.dev.phpVersion !== DEFAULTS.dev.phpVersion) {
+        dev.phpVersion = config.dev.phpVersion;
+      }
+      if (config.dev.wordpressVersion && config.dev.wordpressVersion !== DEFAULTS.dev.wordpressVersion) {
+        dev.wordpressVersion = config.dev.wordpressVersion;
+      }
+      if (config.dev.plugins && config.dev.plugins.length > 0) {
+        dev.plugins = config.dev.plugins;
+      }
+      if (config.dev.sqlDump) {
+        dev.sqlDump = config.dev.sqlDump;
+      }
+      if (Object.keys(dev).length > 0) {
+        result2.dev = dev;
+      }
+    }
+    return result2;
   }
   getConfig() {
     if (!this.config) {
@@ -81344,11 +81113,18 @@ class ConfigManager {
   hasConfig() {
     return fs2.existsSync(this.configPath);
   }
-  getWordPressConfig() {
-    return this.getConfig().wordpress;
+  setDatabaseConnection(connection) {
+    this.runtimeDatabase = connection;
+    if (this.config) {
+      this.config.database = connection;
+    }
   }
-  getSyncPaths() {
-    return this.getConfig().paths;
+  getDatabaseConnection() {
+    return this.config?.database;
+  }
+  getWordPressUrl() {
+    const port = this.config?.dev.port || DEFAULTS.dev.port;
+    return `http://localhost:${port}`;
   }
   resolvePath(relativePath) {
     if (path2.isAbsolute(relativePath)) {
@@ -81359,60 +81135,70 @@ class ConfigManager {
   getConfigDir() {
     return this.configDir;
   }
-  mergeWithEnvCredentials(config2) {
-    const mergedConfig = { ...config2 };
-    if (mergedConfig.wordpress.type === "rest-api") {
-      const password = process.env.WP_APPLICATION_PASSWORD;
-      if (password && password !== "undefined") {
-        mergedConfig.wordpress.applicationPassword = password;
-      }
-    } else if (mergedConfig.wordpress.type === "database") {
-      const password = process.env.DB_PASSWORD;
-      if (password && password !== "undefined") {
-        mergedConfig.wordpress.database.password = password;
+  getLegacyConfig() {
+    const config = this.getConfig();
+    const dbConnection = config.database || {
+      host: "127.0.0.1",
+      port: config.dev.databasePort,
+      database: "wordpress",
+      username: "wordpress",
+      password: "wordpress"
+    };
+    return {
+      wordpress: {
+        type: "database",
+        wordpressUrl: this.getWordPressUrl(),
+        syncPath: config.paths.content,
+        postTypes: ["post", "page"],
+        database: dbConnection
+      },
+      paths: {
+        mdxOutputDir: config.paths.content,
+        postTypeMappings: {
+          post: `${config.paths.content}/post`,
+          page: `${config.paths.content}/page`
+        }
+      },
+      sync: {
+        watchForChanges: true,
+        conflictResolution: "manual",
+        excludePostTypes: config.sync.excludePostTypes,
+        includedPostStatuses: config.sync.includedPostStatuses
+      },
+      build: {
+        blocksDir: config.paths.blocks,
+        outputDir: config.paths.dist,
+        scriptsPath: config.paths.scripts
+      },
+      templates: {
+        templatesDir: config.paths.templates,
+        outputDir: config.paths.templatesOutput
+      },
+      templateParts: {
+        partsDir: config.paths.templateParts,
+        outputDir: config.paths.partsOutput
+      },
+      env: {
+        port: config.dev.port,
+        databasePort: config.dev.databasePort,
+        phpVersion: config.dev.phpVersion,
+        wordpressVersion: config.dev.wordpressVersion,
+        themeDir: config.paths.theme,
+        pluginsDir: config.paths.plugins,
+        plugins: config.dev.plugins,
+        sqlDump: config.dev.sqlDump,
+        volumes: {
+          database: true,
+          uploads: true
+        }
       }
-    }
-    return mergedConfig;
-  }
-  stripSensitiveData(config2) {
-    const strippedConfig = JSON.parse(JSON.stringify(config2));
-    if (strippedConfig.wordpress.type === "rest-api") {
-      delete strippedConfig.wordpress.applicationPassword;
-    } else if (strippedConfig.wordpress.type === "database") {
-      delete strippedConfig.wordpress.database.password;
-    }
-    return strippedConfig;
+    };
   }
-  extractEnvVars(config2) {
-    const envVars = {};
-    if (config2.wordpress.type === "rest-api") {
-      envVars.WP_APPLICATION_PASSWORD = config2.wordpress.applicationPassword;
-    } else if (config2.wordpress.type === "database") {
-      envVars.DB_PASSWORD = config2.wordpress.database.password;
-    }
-    return envVars;
+  getWordPressConfig() {
+    return this.getLegacyConfig().wordpress;
   }
-  async updateEnvFile(newVars) {
-    let envContent = "";
-    if (fs2.existsSync(this.envPath)) {
-      envContent = fs2.readFileSync(this.envPath, "utf8");
-    }
-    const existingVars = {};
-    envContent.split(`
-`).forEach((line) => {
-      const trimmed = line.trim();
-      if (trimmed && !trimmed.startsWith("#")) {
-        const [key, ...valueParts] = trimmed.split("=");
-        if (key && valueParts.length > 0) {
-          existingVars[key.trim()] = valueParts.join("=");
-        }
-      }
-    });
-    const mergedVars = { ...existingVars, ...newVars };
-    const newEnvContent = Object.entries(mergedVars).map(([key, value]) => `${key}=${value}`).join(`
-`) + `
-`;
-    fs2.writeFileSync(this.envPath, newEnvContent);
+  getSyncPaths() {
+    return this.getLegacyConfig().paths;
   }
 }
 // src/config/logger.ts
@@ -81865,7 +81651,7 @@ var utils_default = {
 };
 
 // ../../node_modules/axios/lib/core/AxiosError.js
-function AxiosError(message, code, config2, request, response) {
+function AxiosError(message, code, config, request, response) {
   Error.call(this);
   if (Error.captureStackTrace) {
     Error.captureStackTrace(this, this.constructor);
@@ -81875,7 +81661,7 @@ function AxiosError(message, code, config2, request, response) {
   this.message = message;
   this.name = "AxiosError";
   code && (this.code = code);
-  config2 && (this.config = config2);
+  config && (this.config = config);
   request && (this.request = request);
   if (response) {
     this.response = response;
@@ -81919,7 +81705,7 @@ var descriptors = {};
 });
 Object.defineProperties(AxiosError, descriptors);
 Object.defineProperty(prototype, "isAxiosError", { value: true });
-AxiosError.from = (error, code, config2, request, response, customProps) => {
+AxiosError.from = (error, code, config, request, response, customProps) => {
   const axiosError = Object.create(prototype);
   utils_default.toFlatObject(error, axiosError, function filter(obj) {
     return obj !== Error.prototype;
@@ -81928,7 +81714,7 @@ AxiosError.from = (error, code, config2, request, response, customProps) => {
   });
   const msg = error && error.message ? error.message : "Error";
   const errCode = code == null && error ? error.code : code;
-  AxiosError.call(axiosError, msg, errCode, config2, request, response);
+  AxiosError.call(axiosError, msg, errCode, config, request, response);
   if (error && axiosError.cause == null) {
     Object.defineProperty(axiosError, "cause", { value: error, configurable: true });
   }
@@ -82664,12 +82450,12 @@ var AxiosHeaders_default = AxiosHeaders;
 
 // ../../node_modules/axios/lib/core/transformData.js
 function transformData(fns, response) {
-  const config2 = this || defaults_default;
-  const context = response || config2;
+  const config = this || defaults_default;
+  const context = response || config;
   const headers = AxiosHeaders_default.from(context.headers);
   let data = context.data;
   utils_default.forEach(fns, function transform(fn) {
-    data = fn.call(config2, data, headers.normalize(), response ? response.status : undefined);
+    data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
   });
   headers.normalize();
   return data;
@@ -82681,8 +82467,8 @@ function isCancel(value) {
 }
 
 // ../../node_modules/axios/lib/cancel/CanceledError.js
-function CanceledError(message, config2, request) {
-  AxiosError_default.call(this, message == null ? "canceled" : message, AxiosError_default.ERR_CANCELED, config2, request);
+function CanceledError(message, config, request) {
+  AxiosError_default.call(this, message == null ? "canceled" : message, AxiosError_default.ERR_CANCELED, config, request);
   this.name = "CanceledError";
 }
 utils_default.inherits(CanceledError, AxiosError_default, {
@@ -83379,17 +83165,17 @@ var http2Transport = {
     return req;
   }
 };
-var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
+var http_default = isHttpAdapterSupported && function httpAdapter(config) {
   return wrapAsync(async function dispatchHttpRequest(resolve3, reject, onDone) {
-    let { data, lookup, family, httpVersion = 1, http2Options } = config2;
-    const { responseType, responseEncoding } = config2;
-    const method = config2.method.toUpperCase();
+    let { data, lookup, family, httpVersion = 1, http2Options } = config;
+    const { responseType, responseEncoding } = config;
+    const method = config.method.toUpperCase();
     let isDone;
     let rejected = false;
     let req;
     httpVersion = +httpVersion;
     if (Number.isNaN(httpVersion)) {
-      throw TypeError(`Invalid protocol version: '${config2.httpVersion}' is not a number`);
+      throw TypeError(`Invalid protocol version: '${config.httpVersion}' is not a number`);
     }
     if (httpVersion !== 1 && httpVersion !== 2) {
       throw TypeError(`Unsupported protocol version '${httpVersion}'`);
@@ -83410,25 +83196,25 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
     const abortEmitter = new EventEmitter;
     function abort(reason) {
       try {
-        abortEmitter.emit("abort", !reason || reason.type ? new CanceledError_default(null, config2, req) : reason);
+        abortEmitter.emit("abort", !reason || reason.type ? new CanceledError_default(null, config, req) : reason);
       } catch (err) {
         console.warn("emit error", err);
       }
     }
     abortEmitter.once("abort", reject);
     const onFinished = () => {
-      if (config2.cancelToken) {
-        config2.cancelToken.unsubscribe(abort);
+      if (config.cancelToken) {
+        config.cancelToken.unsubscribe(abort);
       }
-      if (config2.signal) {
-        config2.signal.removeEventListener("abort", abort);
+      if (config.signal) {
+        config.signal.removeEventListener("abort", abort);
       }
       abortEmitter.removeAllListeners();
     };
-    if (config2.cancelToken || config2.signal) {
-      config2.cancelToken && config2.cancelToken.subscribe(abort);
-      if (config2.signal) {
-        config2.signal.aborted ? abort() : config2.signal.addEventListener("abort", abort);
+    if (config.cancelToken || config.signal) {
+      config.cancelToken && config.cancelToken.subscribe(abort);
+      if (config.signal) {
+        config.signal.aborted ? abort() : config.signal.addEventListener("abort", abort);
       }
     }
     onDone((response, isRejected) => {
@@ -83448,15 +83234,15 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
         onFinished();
       }
     });
-    const fullPath = buildFullPath(config2.baseURL, config2.url, config2.allowAbsoluteUrls);
+    const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
     const parsed = new URL(fullPath, platform_default.hasBrowserEnv ? platform_default.origin : undefined);
     const protocol = parsed.protocol || supportedProtocols[0];
     if (protocol === "data:") {
-      if (config2.maxContentLength > -1) {
-        const dataUrl = String(config2.url || fullPath || "");
+      if (config.maxContentLength > -1) {
+        const dataUrl = String(config.url || fullPath || "");
         const estimated = estimateDataURLDecodedBytes(dataUrl);
-        if (estimated > config2.maxContentLength) {
-          return reject(new AxiosError_default("maxContentLength size of " + config2.maxContentLength + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config2));
+        if (estimated > config.maxContentLength) {
+          return reject(new AxiosError_default("maxContentLength size of " + config.maxContentLength + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config));
         }
       }
       let convertedData;
@@ -83465,15 +83251,15 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
           status: 405,
           statusText: "method not allowed",
           headers: {},
-          config: config2
+          config
         });
       }
       try {
-        convertedData = fromDataURI(config2.url, responseType === "blob", {
-          Blob: config2.env && config2.env.Blob
+        convertedData = fromDataURI(config.url, responseType === "blob", {
+          Blob: config.env && config.env.Blob
         });
       } catch (err) {
-        throw AxiosError_default.from(err, AxiosError_default.ERR_BAD_REQUEST, config2);
+        throw AxiosError_default.from(err, AxiosError_default.ERR_BAD_REQUEST, config);
       }
       if (responseType === "text") {
         convertedData = convertedData.toString(responseEncoding);
@@ -83488,16 +83274,16 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
         status: 200,
         statusText: "OK",
         headers: new AxiosHeaders_default,
-        config: config2
+        config
       });
     }
     if (supportedProtocols.indexOf(protocol) === -1) {
-      return reject(new AxiosError_default("Unsupported protocol " + protocol, AxiosError_default.ERR_BAD_REQUEST, config2));
+      return reject(new AxiosError_default("Unsupported protocol " + protocol, AxiosError_default.ERR_BAD_REQUEST, config));
     }
-    const headers = AxiosHeaders_default.from(config2.headers).normalize();
+    const headers = AxiosHeaders_default.from(config.headers).normalize();
     headers.set("User-Agent", "axios/" + VERSION, false);
-    const { onUploadProgress, onDownloadProgress } = config2;
-    const maxRate = config2.maxRate;
+    const { onUploadProgress, onDownloadProgress } = config;
+    const maxRate = config.maxRate;
     let maxUploadRate = undefined;
     let maxDownloadRate = undefined;
     if (utils_default.isSpecCompliantForm(data)) {
@@ -83526,11 +83312,11 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
       } else if (utils_default.isString(data)) {
         data = Buffer.from(data, "utf-8");
       } else {
-        return reject(new AxiosError_default("Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream", AxiosError_default.ERR_BAD_REQUEST, config2));
+        return reject(new AxiosError_default("Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream", AxiosError_default.ERR_BAD_REQUEST, config));
       }
       headers.setContentLength(data.length, false);
-      if (config2.maxBodyLength > -1 && data.length > config2.maxBodyLength) {
-        return reject(new AxiosError_default("Request body larger than maxBodyLength limit", AxiosError_default.ERR_BAD_REQUEST, config2));
+      if (config.maxBodyLength > -1 && data.length > config.maxBodyLength) {
+        return reject(new AxiosError_default("Request body larger than maxBodyLength limit", AxiosError_default.ERR_BAD_REQUEST, config));
       }
     }
     const contentLength = utils_default.toFiniteNumber(headers.getContentLength());
@@ -83550,9 +83336,9 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
       onUploadProgress && data.on("progress", flushOnFinish(data, progressEventDecorator(contentLength, progressEventReducer(asyncDecorator(onUploadProgress), false, 3))));
     }
     let auth = undefined;
-    if (config2.auth) {
-      const username = config2.auth.username || "";
-      const password = config2.auth.password || "";
+    if (config.auth) {
+      const username = config.auth.username || "";
+      const password = config.auth.password || "";
       auth = username + ":" + password;
     }
     if (!auth && parsed.username) {
@@ -83563,11 +83349,11 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
     auth && headers.delete("authorization");
     let path3;
     try {
-      path3 = buildURL(parsed.pathname + parsed.search, config2.params, config2.paramsSerializer).replace(/^\?/, "");
+      path3 = buildURL(parsed.pathname + parsed.search, config.params, config.paramsSerializer).replace(/^\?/, "");
     } catch (err) {
       const customErr = new Error(err.message);
-      customErr.config = config2;
-      customErr.url = config2.url;
+      customErr.config = config;
+      customErr.url = config.url;
       customErr.exists = true;
       return reject(customErr);
     }
@@ -83576,7 +83362,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
       path: path3,
       method,
       headers: headers.toJSON(),
-      agents: { http: config2.httpAgent, https: config2.httpsAgent },
+      agents: { http: config.httpAgent, https: config.httpsAgent },
       auth,
       protocol,
       family,
@@ -83585,40 +83371,40 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
       http2Options
     };
     !utils_default.isUndefined(lookup) && (options.lookup = lookup);
-    if (config2.socketPath) {
-      options.socketPath = config2.socketPath;
+    if (config.socketPath) {
+      options.socketPath = config.socketPath;
     } else {
       options.hostname = parsed.hostname.startsWith("[") ? parsed.hostname.slice(1, -1) : parsed.hostname;
       options.port = parsed.port;
-      setProxy(options, config2.proxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path);
+      setProxy(options, config.proxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path);
     }
     let transport;
     const isHttpsRequest = isHttps.test(options.protocol);
-    options.agent = isHttpsRequest ? config2.httpsAgent : config2.httpAgent;
+    options.agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
     if (isHttp2) {
       transport = http2Transport;
     } else {
-      if (config2.transport) {
-        transport = config2.transport;
-      } else if (config2.maxRedirects === 0) {
+      if (config.transport) {
+        transport = config.transport;
+      } else if (config.maxRedirects === 0) {
         transport = isHttpsRequest ? https : http;
       } else {
-        if (config2.maxRedirects) {
-          options.maxRedirects = config2.maxRedirects;
+        if (config.maxRedirects) {
+          options.maxRedirects = config.maxRedirects;
         }
-        if (config2.beforeRedirect) {
-          options.beforeRedirects.config = config2.beforeRedirect;
+        if (config.beforeRedirect) {
+          options.beforeRedirects.config = config.beforeRedirect;
         }
         transport = isHttpsRequest ? httpsFollow : httpFollow;
       }
     }
-    if (config2.maxBodyLength > -1) {
-      options.maxBodyLength = config2.maxBodyLength;
+    if (config.maxBodyLength > -1) {
+      options.maxBodyLength = config.maxBodyLength;
     } else {
       options.maxBodyLength = Infinity;
     }
-    if (config2.insecureHTTPParser) {
-      options.insecureHTTPParser = config2.insecureHTTPParser;
+    if (config.insecureHTTPParser) {
+      options.insecureHTTPParser = config.insecureHTTPParser;
     }
     req = transport.request(options, function handleResponse(res) {
       if (req.destroyed)
@@ -83634,7 +83420,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
       }
       let responseStream = res;
       const lastRequest = res.req || req;
-      if (config2.decompress !== false && res.headers["content-encoding"]) {
+      if (config.decompress !== false && res.headers["content-encoding"]) {
         if (method === "HEAD" || res.statusCode === 204) {
           delete res.headers["content-encoding"];
         }
@@ -83663,7 +83449,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
         status: res.statusCode,
         statusText: res.statusMessage,
         headers: new AxiosHeaders_default(res.headers),
-        config: config2,
+        config,
         request: lastRequest
       };
       if (responseType === "stream") {
@@ -83675,24 +83461,24 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
         responseStream.on("data", function handleStreamData(chunk) {
           responseBuffer.push(chunk);
           totalResponseBytes += chunk.length;
-          if (config2.maxContentLength > -1 && totalResponseBytes > config2.maxContentLength) {
+          if (config.maxContentLength > -1 && totalResponseBytes > config.maxContentLength) {
             rejected = true;
             responseStream.destroy();
-            abort(new AxiosError_default("maxContentLength size of " + config2.maxContentLength + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config2, lastRequest));
+            abort(new AxiosError_default("maxContentLength size of " + config.maxContentLength + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config, lastRequest));
           }
         });
         responseStream.on("aborted", function handlerStreamAborted() {
           if (rejected) {
             return;
           }
-          const err = new AxiosError_default("stream has been aborted", AxiosError_default.ERR_BAD_RESPONSE, config2, lastRequest);
+          const err = new AxiosError_default("stream has been aborted", AxiosError_default.ERR_BAD_RESPONSE, config, lastRequest);
           responseStream.destroy(err);
           reject(err);
         });
         responseStream.on("error", function handleStreamError(err) {
           if (req.destroyed)
             return;
-          reject(AxiosError_default.from(err, null, config2, lastRequest));
+          reject(AxiosError_default.from(err, null, config, lastRequest));
         });
         responseStream.on("end", function handleStreamEnd() {
           try {
@@ -83705,7 +83491,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
             }
             response.data = responseData;
           } catch (err) {
-            return reject(AxiosError_default.from(err, null, config2, response.request, response));
+            return reject(AxiosError_default.from(err, null, config, response.request, response));
           }
           settle(resolve3, reject, response);
         });
@@ -83725,26 +83511,26 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
       }
     });
     req.on("error", function handleRequestError(err) {
-      reject(AxiosError_default.from(err, null, config2, req));
+      reject(AxiosError_default.from(err, null, config, req));
     });
     req.on("socket", function handleRequestSocket(socket) {
       socket.setKeepAlive(true, 1000 * 60);
     });
-    if (config2.timeout) {
-      const timeout = parseInt(config2.timeout, 10);
+    if (config.timeout) {
+      const timeout = parseInt(config.timeout, 10);
       if (Number.isNaN(timeout)) {
-        abort(new AxiosError_default("error trying to parse `config.timeout` to int", AxiosError_default.ERR_BAD_OPTION_VALUE, config2, req));
+        abort(new AxiosError_default("error trying to parse `config.timeout` to int", AxiosError_default.ERR_BAD_OPTION_VALUE, config, req));
         return;
       }
       req.setTimeout(timeout, function handleRequestTimeout() {
         if (isDone)
           return;
-        let timeoutErrorMessage = config2.timeout ? "timeout of " + config2.timeout + "ms exceeded" : "timeout exceeded";
-        const transitional = config2.transitional || transitional_default;
-        if (config2.timeoutErrorMessage) {
-          timeoutErrorMessage = config2.timeoutErrorMessage;
+        let timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
+        const transitional = config.transitional || transitional_default;
+        if (config.timeoutErrorMessage) {
+          timeoutErrorMessage = config.timeoutErrorMessage;
         }
-        abort(new AxiosError_default(timeoutErrorMessage, transitional.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED, config2, req));
+        abort(new AxiosError_default(timeoutErrorMessage, transitional.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED, config, req));
       });
     } else {
       req.setTimeout(0);
@@ -83761,7 +83547,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
       });
       data.on("close", () => {
         if (!ended && !errored) {
-          abort(new CanceledError_default("Request stream has been aborted", config2, req));
+          abort(new CanceledError_default("Request stream has been aborted", config, req));
         }
       });
       data.pipe(req);
@@ -83822,7 +83608,7 @@ var cookies_default = platform_default.hasStandardBrowserEnv ? {
 var headersToObject = (thing) => thing instanceof AxiosHeaders_default ? { ...thing } : thing;
 function mergeConfig(config1, config2) {
   config2 = config2 || {};
-  const config3 = {};
+  const config = {};
   function getMergedValue(target, source, prop, caseless) {
     if (utils_default.isPlainObject(target) && utils_default.isPlainObject(source)) {
       return utils_default.merge.call({ caseless }, target, source);
@@ -83893,17 +83679,17 @@ function mergeConfig(config1, config2) {
   utils_default.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {
     const merge2 = mergeMap[prop] || mergeDeepProperties;
     const configValue = merge2(config1[prop], config2[prop], prop);
-    utils_default.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config3[prop] = configValue);
+    utils_default.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
   });
-  return config3;
+  return config;
 }
 
 // ../../node_modules/axios/lib/helpers/resolveConfig.js
-var resolveConfig_default = (config2) => {
-  const newConfig = mergeConfig({}, config2);
+var resolveConfig_default = (config) => {
+  const newConfig = mergeConfig({}, config);
   let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
   newConfig.headers = headers = AxiosHeaders_default.from(headers);
-  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config2.params, config2.paramsSerializer);
+  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer);
   if (auth) {
     headers.set("Authorization", "Basic " + btoa((auth.username || "") + ":" + (auth.password ? unescape(encodeURIComponent(auth.password)) : "")));
   }
@@ -83934,9 +83720,9 @@ var resolveConfig_default = (config2) => {
 
 // ../../node_modules/axios/lib/adapters/xhr.js
 var isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
-var xhr_default = isXHRAdapterSupported && function(config2) {
+var xhr_default = isXHRAdapterSupported && function(config) {
   return new Promise(function dispatchXhrRequest(resolve3, reject) {
-    const _config = resolveConfig_default(config2);
+    const _config = resolveConfig_default(config);
     let requestData = _config.data;
     const requestHeaders = AxiosHeaders_default.from(_config.headers).normalize();
     let { responseType, onUploadProgress, onDownloadProgress } = _config;
@@ -83963,7 +83749,7 @@ var xhr_default = isXHRAdapterSupported && function(config2) {
         status: request.status,
         statusText: request.statusText,
         headers: responseHeaders,
-        config: config2,
+        config,
         request
       };
       settle(function _resolve(value) {
@@ -83992,12 +83778,12 @@ var xhr_default = isXHRAdapterSupported && function(config2) {
       if (!request) {
         return;
       }
-      reject(new AxiosError_default("Request aborted", AxiosError_default.ECONNABORTED, config2, request));
+      reject(new AxiosError_default("Request aborted", AxiosError_default.ECONNABORTED, config, request));
       request = null;
     };
     request.onerror = function handleError(event) {
       const msg = event && event.message ? event.message : "Network Error";
-      const err = new AxiosError_default(msg, AxiosError_default.ERR_NETWORK, config2, request);
+      const err = new AxiosError_default(msg, AxiosError_default.ERR_NETWORK, config, request);
       err.event = event || null;
       reject(err);
       request = null;
@@ -84008,7 +83794,7 @@ var xhr_default = isXHRAdapterSupported && function(config2) {
       if (_config.timeoutErrorMessage) {
         timeoutErrorMessage = _config.timeoutErrorMessage;
       }
-      reject(new AxiosError_default(timeoutErrorMessage, transitional.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED, config2, request));
+      reject(new AxiosError_default(timeoutErrorMessage, transitional.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED, config, request));
       request = null;
     };
     requestData === undefined && requestHeaders.setContentType(null);
@@ -84037,7 +83823,7 @@ var xhr_default = isXHRAdapterSupported && function(config2) {
         if (!request) {
           return;
         }
-        reject(!cancel || cancel.type ? new CanceledError_default(null, config2, request) : cancel);
+        reject(!cancel || cancel.type ? new CanceledError_default(null, config, request) : cancel);
         request.abort();
         request = null;
       };
@@ -84048,7 +83834,7 @@ var xhr_default = isXHRAdapterSupported && function(config2) {
     }
     const protocol = parseProtocol(_config.url);
     if (protocol && platform_default.protocols.indexOf(protocol) === -1) {
-      reject(new AxiosError_default("Unsupported protocol " + protocol + ":", AxiosError_default.ERR_BAD_REQUEST, config2));
+      reject(new AxiosError_default("Unsupported protocol " + protocol + ":", AxiosError_default.ERR_BAD_REQUEST, config));
       return;
     }
     request.send(requestData || null);
@@ -84217,12 +84003,12 @@ var factory = (env) => {
   };
   isFetchSupported && (() => {
     ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((type) => {
-      !resolvers[type] && (resolvers[type] = (res, config2) => {
+      !resolvers[type] && (resolvers[type] = (res, config) => {
         let method = res && res[type];
         if (method) {
           return method.call(res);
         }
-        throw new AxiosError_default(`Response type '${type}' is not supported`, AxiosError_default.ERR_NOT_SUPPORT, config2);
+        throw new AxiosError_default(`Response type '${type}' is not supported`, AxiosError_default.ERR_NOT_SUPPORT, config);
       });
     });
   })();
@@ -84254,7 +84040,7 @@ var factory = (env) => {
     const length = utils_default.toFiniteNumber(headers.getContentLength());
     return length == null ? getBodyLength(body) : length;
   };
-  return async (config2) => {
+  return async (config) => {
     let {
       url: url2,
       method,
@@ -84268,7 +84054,7 @@ var factory = (env) => {
       headers,
       withCredentials = "same-origin",
       fetchOptions
-    } = resolveConfig_default(config2);
+    } = resolveConfig_default(config);
     let _fetch = envFetch || fetch;
     responseType = responseType ? (responseType + "").toLowerCase() : "text";
     let composedSignal = composeSignals_default([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
@@ -84322,7 +84108,7 @@ var factory = (env) => {
         }), options);
       }
       responseType = responseType || "text";
-      let responseData = await resolvers[utils_default.findKey(resolvers, responseType) || "text"](response, config2);
+      let responseData = await resolvers[utils_default.findKey(resolvers, responseType) || "text"](response, config);
       !isStreamResponse && unsubscribe && unsubscribe();
       return await new Promise((resolve3, reject) => {
         settle(resolve3, reject, {
@@ -84330,24 +84116,24 @@ var factory = (env) => {
           headers: AxiosHeaders_default.from(response.headers),
           status: response.status,
           statusText: response.statusText,
-          config: config2,
+          config,
           request
         });
       });
     } catch (err) {
       unsubscribe && unsubscribe();
       if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) {
-        throw Object.assign(new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config2, request), {
+        throw Object.assign(new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config, request), {
           cause: err.cause || err
         });
       }
-      throw AxiosError_default.from(err, err && err.code, config2, request);
+      throw AxiosError_default.from(err, err && err.code, config, request);
     }
   };
 };
 var seedCache = new Map;
-var getFetch = (config2) => {
-  let env = config2 && config2.env || {};
+var getFetch = (config) => {
+  let env = config && config.env || {};
   const { fetch: fetch2, Request, Response } = env;
   const seeds = [
     Request,
@@ -84383,7 +84169,7 @@ utils_default.forEach(knownAdapters, (fn, value) => {
 });
 var renderReason = (reason) => `- ${reason}`;
 var isResolvedHandle = (adapter2) => utils_default.isFunction(adapter2) || adapter2 === null || adapter2 === false;
-function getAdapter(adapters, config2) {
+function getAdapter(adapters, config) {
   adapters = utils_default.isArray(adapters) ? adapters : [adapters];
   const { length } = adapters;
   let nameOrAdapter;
@@ -84399,7 +84185,7 @@ function getAdapter(adapters, config2) {
         throw new AxiosError_default(`Unknown adapter '${id}'`);
       }
     }
-    if (adapter2 && (utils_default.isFunction(adapter2) || (adapter2 = adapter2.get(config2)))) {
+    if (adapter2 && (utils_default.isFunction(adapter2) || (adapter2 = adapter2.get(config)))) {
       break;
     }
     rejectedReasons[id || "#" + i] = adapter2;
@@ -84419,32 +84205,32 @@ var adapters_default = {
 };
 
 // ../../node_modules/axios/lib/core/dispatchRequest.js
-function throwIfCancellationRequested(config2) {
-  if (config2.cancelToken) {
-    config2.cancelToken.throwIfRequested();
+function throwIfCancellationRequested(config) {
+  if (config.cancelToken) {
+    config.cancelToken.throwIfRequested();
   }
-  if (config2.signal && config2.signal.aborted) {
-    throw new CanceledError_default(null, config2);
+  if (config.signal && config.signal.aborted) {
+    throw new CanceledError_default(null, config);
   }
 }
-function dispatchRequest(config2) {
-  throwIfCancellationRequested(config2);
-  config2.headers = AxiosHeaders_default.from(config2.headers);
-  config2.data = transformData.call(config2, config2.transformRequest);
-  if (["post", "put", "patch"].indexOf(config2.method) !== -1) {
-    config2.headers.setContentType("application/x-www-form-urlencoded", false);
+function dispatchRequest(config) {
+  throwIfCancellationRequested(config);
+  config.headers = AxiosHeaders_default.from(config.headers);
+  config.data = transformData.call(config, config.transformRequest);
+  if (["post", "put", "patch"].indexOf(config.method) !== -1) {
+    config.headers.setContentType("application/x-www-form-urlencoded", false);
   }
-  const adapter2 = adapters_default.getAdapter(config2.adapter || defaults_default.adapter, config2);
-  return adapter2(config2).then(function onAdapterResolution(response) {
-    throwIfCancellationRequested(config2);
-    response.data = transformData.call(config2, config2.transformResponse, response);
+  const adapter2 = adapters_default.getAdapter(config.adapter || defaults_default.adapter, config);
+  return adapter2(config).then(function onAdapterResolution(response) {
+    throwIfCancellationRequested(config);
+    response.data = transformData.call(config, config.transformResponse, response);
     response.headers = AxiosHeaders_default.from(response.headers);
     return response;
   }, function onAdapterRejection(reason) {
     if (!isCancel(reason)) {
-      throwIfCancellationRequested(config2);
+      throwIfCancellationRequested(config);
       if (reason && reason.response) {
-        reason.response.data = transformData.call(config2, config2.transformResponse, reason.response);
+        reason.response.data = transformData.call(config, config.transformResponse, reason.response);
         reason.response.headers = AxiosHeaders_default.from(reason.response.headers);
       }
     }
@@ -84519,9 +84305,9 @@ class Axios {
       response: new InterceptorManager_default
     };
   }
-  async request(configOrUrl, config2) {
+  async request(configOrUrl, config) {
     try {
-      return await this._request(configOrUrl, config2);
+      return await this._request(configOrUrl, config);
     } catch (err) {
       if (err instanceof Error) {
         let dummy = {};
@@ -84539,15 +84325,15 @@ class Axios {
       throw err;
     }
   }
-  _request(configOrUrl, config2) {
+  _request(configOrUrl, config) {
     if (typeof configOrUrl === "string") {
-      config2 = config2 || {};
-      config2.url = configOrUrl;
+      config = config || {};
+      config.url = configOrUrl;
     } else {
-      config2 = configOrUrl || {};
+      config = configOrUrl || {};
     }
-    config2 = mergeConfig(this.defaults, config2);
-    const { transitional: transitional2, paramsSerializer, headers } = config2;
+    config = mergeConfig(this.defaults, config);
+    const { transitional: transitional2, paramsSerializer, headers } = config;
     if (transitional2 !== undefined) {
       validator_default.assertOptions(transitional2, {
         silentJSONParsing: validators2.transitional(validators2.boolean),
@@ -84557,7 +84343,7 @@ class Axios {
     }
     if (paramsSerializer != null) {
       if (utils_default.isFunction(paramsSerializer)) {
-        config2.paramsSerializer = {
+        config.paramsSerializer = {
           serialize: paramsSerializer
         };
       } else {
@@ -84567,25 +84353,25 @@ class Axios {
         }, true);
       }
     }
-    if (config2.allowAbsoluteUrls !== undefined) {} else if (this.defaults.allowAbsoluteUrls !== undefined) {
-      config2.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
+    if (config.allowAbsoluteUrls !== undefined) {} else if (this.defaults.allowAbsoluteUrls !== undefined) {
+      config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
     } else {
-      config2.allowAbsoluteUrls = true;
+      config.allowAbsoluteUrls = true;
     }
-    validator_default.assertOptions(config2, {
+    validator_default.assertOptions(config, {
       baseUrl: validators2.spelling("baseURL"),
       withXsrfToken: validators2.spelling("withXSRFToken")
     }, true);
-    config2.method = (config2.method || this.defaults.method || "get").toLowerCase();
-    let contextHeaders = headers && utils_default.merge(headers.common, headers[config2.method]);
+    config.method = (config.method || this.defaults.method || "get").toLowerCase();
+    let contextHeaders = headers && utils_default.merge(headers.common, headers[config.method]);
     headers && utils_default.forEach(["delete", "get", "head", "post", "put", "patch", "common"], (method) => {
       delete headers[method];
     });
-    config2.headers = AxiosHeaders_default.concat(contextHeaders, headers);
+    config.headers = AxiosHeaders_default.concat(contextHeaders, headers);
     const requestInterceptorChain = [];
     let synchronousRequestInterceptors = true;
     this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
-      if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config2) === false) {
+      if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
         return;
       }
       synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
@@ -84603,14 +84389,14 @@ class Axios {
       chain.unshift(...requestInterceptorChain);
       chain.push(...responseInterceptorChain);
       len = chain.length;
-      promise = Promise.resolve(config2);
+      promise = Promise.resolve(config);
       while (i < len) {
         promise = promise.then(chain[i++], chain[i++]);
       }
       return promise;
     }
     len = requestInterceptorChain.length;
-    let newConfig = config2;
+    let newConfig = config;
     while (i < len) {
       const onFulfilled = requestInterceptorChain[i++];
       const onRejected = requestInterceptorChain[i++];
@@ -84633,25 +84419,25 @@ class Axios {
     }
     return promise;
   }
-  getUri(config2) {
-    config2 = mergeConfig(this.defaults, config2);
-    const fullPath = buildFullPath(config2.baseURL, config2.url, config2.allowAbsoluteUrls);
-    return buildURL(fullPath, config2.params, config2.paramsSerializer);
+  getUri(config) {
+    config = mergeConfig(this.defaults, config);
+    const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
+    return buildURL(fullPath, config.params, config.paramsSerializer);
   }
 }
 utils_default.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
-  Axios.prototype[method] = function(url2, config2) {
-    return this.request(mergeConfig(config2 || {}, {
+  Axios.prototype[method] = function(url2, config) {
+    return this.request(mergeConfig(config || {}, {
       method,
       url: url2,
-      data: (config2 || {}).data
+      data: (config || {}).data
     }));
   };
 });
 utils_default.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
   function generateHTTPMethod(isForm) {
-    return function httpMethod(url2, data, config2) {
-      return this.request(mergeConfig(config2 || {}, {
+    return function httpMethod(url2, data, config) {
+      return this.request(mergeConfig(config || {}, {
         method,
         headers: isForm ? {
           "Content-Type": "multipart/form-data"
@@ -84697,11 +84483,11 @@ class CancelToken {
       };
       return promise;
     };
-    executor(function cancel(message, config2, request) {
+    executor(function cancel(message, config, request) {
       if (token.reason) {
         return;
       }
-      token.reason = new CanceledError_default(message, config2, request);
+      token.reason = new CanceledError_default(message, config, request);
       resolvePromise(token.reason);
     });
   }
@@ -84878,20 +84664,20 @@ var axios_default = axios;
 class RestApiClient {
   client;
   config;
-  constructor(config2) {
-    this.config = config2;
-    const auth = Buffer.from(`${config2.username}:${config2.applicationPassword}`).toString("base64");
+  constructor(config) {
+    this.config = config;
+    const auth = Buffer.from(`${config.username}:${config.applicationPassword}`).toString("base64");
     this.client = axios_default.create({
-      baseURL: `${config2.wordpressUrl}/wp-json/wp/v2`,
+      baseURL: `${config.wordpressUrl}/wp-json/wp/v2`,
       headers: {
         Authorization: `Basic ${auth}`,
         "Content-Type": "application/json"
       },
       timeout: 30000
     });
-    this.client.interceptors.request.use((config3) => {
-      logger.debug(`Making request: ${config3.method?.toUpperCase()} ${config3.url}`);
-      return config3;
+    this.client.interceptors.request.use((config2) => {
+      logger.debug(`Making request: ${config2.method?.toUpperCase()} ${config2.url}`);
+      return config2;
     }, (error) => {
       logger.error("Request error:", error);
       return Promise.reject(error);
@@ -85049,8 +84835,8 @@ var mysql = __toESM(require_promise(), 1);
 class DatabaseClient {
   connection = null;
   config;
-  constructor(config2) {
-    this.config = config2;
+  constructor(config) {
+    this.config = config;
   }
   async connect() {
     if (this.connection) {
@@ -85147,8 +84933,7 @@ class DatabaseClient {
       const perPage = params.per_page || 100;
       const page = params.page || 1;
       const offset = (page - 1) * perPage;
-      query += " LIMIT ? OFFSET ?";
-      queryParams.push(perPage, offset);
+      query += ` LIMIT ${Number(perPage)} OFFSET ${Number(offset)}`;
       logger.debug(`Executing query: ${query}`);
       logger.debug(`Query parameters: ${JSON.stringify(queryParams)}`);
       const [rows] = await this.connection.execute(query, queryParams);
@@ -85464,6 +85249,7 @@ class DatabaseClient {
 class ConnectionManager {
   static instance;
   connection = null;
+  currentConfig = null;
   constructor() {}
   static getInstance() {
     if (!ConnectionManager.instance) {
@@ -85471,20 +85257,44 @@ class ConnectionManager {
     }
     return ConnectionManager.instance;
   }
-  async createConnection(config2) {
-    if (config2.type === "rest-api") {
-      this.connection = new RestApiClient(config2);
-    } else if (config2.type === "database") {
-      this.connection = new DatabaseClient(config2);
+  hasConnection() {
+    return this.connection !== null;
+  }
+  async createConnection(config) {
+    if (this.connection && this.currentConfig) {
+      const configMatches = this.configsMatch(this.currentConfig, config);
+      if (configMatches) {
+        return this.connection;
+      }
+      await this.closeConnection();
+    }
+    if (config.type === "rest-api") {
+      this.connection = new RestApiClient(config);
+    } else if (config.type === "database") {
+      this.connection = new DatabaseClient(config);
     } else {
-      throw new Error(`Unsupported connection type: ${config2.type}`);
+      throw new Error(`Unsupported connection type: ${config.type}`);
     }
     const isConnected = await this.connection.testConnection();
     if (!isConnected) {
       throw new Error("Failed to establish connection to WordPress");
     }
+    this.currentConfig = config;
     return this.connection;
   }
+  configsMatch(a, b) {
+    if (a.type !== b.type)
+      return false;
+    if (a.wordpressUrl !== b.wordpressUrl)
+      return false;
+    if (a.type === "database" && b.type === "database") {
+      return a.database.host === b.database.host && a.database.port === b.database.port && a.database.database === b.database.database && a.database.username === b.database.username;
+    }
+    if (a.type === "rest-api" && b.type === "rest-api") {
+      return a.username === b.username;
+    }
+    return true;
+  }
   getConnection() {
     if (!this.connection) {
       throw new Error("No connection established. Call createConnection() first.");
@@ -85496,6 +85306,7 @@ class ConnectionManager {
       await this.connection.close();
     }
     this.connection = null;
+    this.currentConfig = null;
   }
 }
 // ../../node_modules/@wordpress/block-serialization-default-parser/build-module/index.js
@@ -85980,8 +85791,9 @@ class PullCommand {
   }
   async execute(options) {
     logger.progress("Starting pull operation...");
-    const config2 = this.configManager.getConfig();
-    const connection = await this.connectionManager.createConnection(config2.wordpress);
+    const config = this.configManager.getConfig();
+    const legacyConfig = this.configManager.getLegacyConfig();
+    const connection = await this.connectionManager.createConnection(legacyConfig.wordpress);
     const result2 = {
       success: false,
       operation: {
@@ -85993,7 +85805,7 @@ class PullCommand {
         },
         target: {
           type: "local",
-          identifier: options.outputDir || config2.paths.mdxOutputDir,
+          identifier: options.outputDir || config.paths.content,
           lastModified: new Date
         },
         timestamp: new Date,
@@ -86003,8 +85815,8 @@ class PullCommand {
       errors: []
     };
     try {
-      const postTypes = options.postTypes || config2.wordpress.postTypes || ["post", "page"];
-      const outputDir = options.outputDir || config2.paths.mdxOutputDir;
+      const postTypes = options.postTypes || ["post", "page"];
+      const outputDir = options.outputDir || config.paths.content;
       fs3.mkdirSync(outputDir, { recursive: true });
       let totalProcessed = 0;
       for (const postType of postTypes) {
@@ -86079,13 +85891,7 @@ class PullCommand {
       title: post.title.rendered,
       slug: post.slug,
       postId: post.id,
-      status: post.status,
-      date: new Date(post.date).toISOString(),
-      modified: new Date(post.modified).toISOString(),
-      excerpt: post.excerpt.rendered || "",
-      categories: post.categories || [],
-      tags: post.tags || [],
-      meta: post.meta || {}
+      status: post.status
     };
     const mdxContent = this.generateMDX(blocks, frontmatter);
     fs3.writeFileSync(filePath2, mdxContent, "utf8");
@@ -92118,8 +91924,8 @@ function walk(ast, { enter, leave }) {
 // ../../node_modules/estree-util-build-jsx/lib/index.js
 var regex = /@(jsx|jsxFrag|jsxImportSource|jsxRuntime)\s+(\S+)/g;
 function buildJsx(tree, options) {
-  const config2 = options || {};
-  let automatic = config2.runtime === "automatic";
+  const config = options || {};
+  let automatic = config.runtime === "automatic";
   const annotations = {};
   const imports = {};
   walk(tree, {
@@ -92201,7 +92007,7 @@ function buildJsx(tree, options) {
             specifiers,
             source: {
               type: "Literal",
-              value: (annotations.jsxImportSource || config2.importSource || "react") + (config2.development ? "/jsx-dev-runtime" : "/jsx-runtime")
+              value: (annotations.jsxImportSource || config.importSource || "react") + (config.development ? "/jsx-dev-runtime" : "/jsx-runtime")
             }
           });
         }
@@ -92272,7 +92078,7 @@ function buildJsx(tree, options) {
         imports.fragment = true;
         name2 = { type: "Identifier", name: "_Fragment" };
       } else {
-        name2 = toMemberExpression(annotations.jsxFrag || config2.pragmaFrag || "React.Fragment");
+        name2 = toMemberExpression(annotations.jsxFrag || config.pragmaFrag || "React.Fragment");
       }
       if (automatic) {
         if (children.length > 0) {
@@ -92294,11 +92100,11 @@ function buildJsx(tree, options) {
         parameters.push({ type: "ObjectExpression", properties: fields });
         if (key) {
           parameters.push(key);
-        } else if (config2.development) {
+        } else if (config.development) {
           parameters.push({ type: "Identifier", name: "undefined" });
         }
         const isStaticChildren = children.length > 1;
-        if (config2.development) {
+        if (config.development) {
           imports.jsxDEV = true;
           callee = {
             type: "Identifier",
@@ -92317,7 +92123,7 @@ function buildJsx(tree, options) {
                 key: { type: "Identifier", name: "fileName" },
                 value: {
                   type: "Literal",
-                  value: config2.filePath || "<source.js>"
+                  value: config.filePath || "<source.js>"
                 }
               }
             ]
@@ -92355,7 +92161,7 @@ function buildJsx(tree, options) {
         } else if (parameters.length > 0) {
           parameters.unshift({ type: "Literal", value: null });
         }
-        callee = toMemberExpression(annotations.jsx || config2.pragma || "React.createElement");
+        callee = toMemberExpression(annotations.jsx || config.pragma || "React.createElement");
       }
       parameters.unshift(name2);
       const call = {
@@ -109224,7 +109030,7 @@ function fromMarkdown(value, encoding, options) {
   return compiler(options)(postprocess(parse4(options).document().write(preprocess()(value, encoding, true))));
 }
 function compiler(options) {
-  const config2 = {
+  const config = {
     transforms: [],
     canContainEols: ["emphasis", "fragment", "heading", "paragraph", "strong"],
     enter: {
@@ -109322,7 +109128,7 @@ function compiler(options) {
       thematicBreak: closer()
     }
   };
-  configure(config2, (options || {}).mdastExtensions || []);
+  configure(config, (options || {}).mdastExtensions || []);
   const data2 = {};
   return compile;
   function compile(events) {
@@ -109330,7 +109136,7 @@ function compiler(options) {
     const context = {
       stack: [tree],
       tokenStack: [],
-      config: config2,
+      config,
       enter,
       exit: exit2,
       buffer,
@@ -109352,7 +109158,7 @@ function compiler(options) {
     }
     index2 = -1;
     while (++index2 < events.length) {
-      const handler = config2[events[index2][0]];
+      const handler = config[events[index2][0]];
       if (own7.call(handler, events[index2][1].type)) {
         handler[events[index2][1].type].call(Object.assign({ sliceSerialize: events[index2][2].sliceSerialize }, context), events[index2][1]);
       }
@@ -109367,8 +109173,8 @@ function compiler(options) {
       end: point3(events.length > 0 ? events[events.length - 2][1].end : { line: 1, column: 1, offset: 0 })
     };
     index2 = -1;
-    while (++index2 < config2.transforms.length) {
-      tree = config2.transforms[index2](tree) || tree;
+    while (++index2 < config.transforms.length) {
+      tree = config.transforms[index2](tree) || tree;
     }
     return tree;
   }
@@ -109639,7 +109445,7 @@ function compiler(options) {
       this.data.atHardBreak = undefined;
       return;
     }
-    if (!this.data.setextHeadingSlurpLineEnding && config2.canContainEols.includes(context.type)) {
+    if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context.type)) {
       onenterdata.call(this, token);
       onexitdata.call(this, token);
     }
@@ -113251,8 +113057,8 @@ class PushCommand {
     if (blockRegistry) {
       this.blockRegistry = blockRegistry;
     } else {
-      const config2 = this.configManager.getConfig();
-      const buildOutputDir = this.configManager.resolvePath(config2.build?.outputDir || "./theme/dist");
+      const config = this.configManager.getConfig();
+      const buildOutputDir = this.configManager.resolvePath(config.paths.dist);
       this.blockRegistry = new BlockRegistry(buildOutputDir);
     }
   }
@@ -113329,8 +113135,9 @@ class PushCommand {
       logger.warn(`Failed to load built blocks: ${error.message}`);
       logger.warn("Continuing with basic block rendering...");
     }
-    const config2 = this.configManager.getConfig();
-    const connection = await this.connectionManager.createConnection(config2.wordpress);
+    const config = this.configManager.getConfig();
+    const legacyConfig = this.configManager.getLegacyConfig();
+    const connection = await this.connectionManager.createConnection(legacyConfig.wordpress);
     const result2 = {
       success: false,
       operation: {
@@ -113342,7 +113149,7 @@ class PushCommand {
         },
         target: {
           type: "wordpress",
-          identifier: config2.wordpress.wordpressUrl,
+          identifier: this.configManager.getWordPressUrl(),
           lastModified: new Date
         },
         timestamp: new Date,
@@ -113353,7 +113160,7 @@ class PushCommand {
       conflicts: []
     };
     try {
-      const mdxFiles = await this.findMDXFiles(options.files, config2.paths.mdxOutputDir);
+      const mdxFiles = await this.findMDXFiles(options.files, config.paths.content);
       if (mdxFiles.length === 0) {
         logger.warn("No MDX files found to push");
         result2.operation.status = "completed";
@@ -113383,7 +113190,7 @@ class PushCommand {
         logger.warn(`Found ${result2.conflicts.length} file(s) with conflicts (WordPress version is newer)`);
         logger.info(`Use --force to override, or pull latest changes first`);
         logger.debug(`Conflict details:`);
-        await this.handleConflicts(result2.conflicts, config2.sync.conflictResolution);
+        await this.handleConflicts(result2.conflicts, config.sync.conflictResolution);
       }
       result2.operation.status = "completed";
       result2.success = result2.errors.length === 0 || result2.errors.every((e) => e.recoverable);
@@ -113411,8 +113218,14 @@ class PushCommand {
     try {
       await this.blockRegistry.loadBuiltBlocks();
     } catch {}
-    const config2 = this.configManager.getConfig();
-    const connection = await this.connectionManager.createConnection(config2.wordpress);
+    const config = this.configManager.getConfig();
+    const legacyConfig = this.configManager.getLegacyConfig();
+    let connection;
+    if (this.connectionManager.hasConnection()) {
+      connection = this.connectionManager.getConnection();
+    } else {
+      connection = await this.connectionManager.createConnection(legacyConfig.wordpress);
+    }
     const result2 = {
       success: false,
       operation: {
@@ -113424,7 +113237,7 @@ class PushCommand {
         },
         target: {
           type: "wordpress",
-          identifier: config2.wordpress.wordpressUrl,
+          identifier: this.configManager.getWordPressUrl(),
           lastModified: new Date
         },
         timestamp: new Date,
@@ -113435,7 +113248,7 @@ class PushCommand {
       conflicts: []
     };
     try {
-      const mdxFiles = await this.findMDXFiles(options.files, config2.paths.mdxOutputDir);
+      const mdxFiles = await this.findMDXFiles(options.files, config.paths.content);
       if (mdxFiles.length === 0) {
         result2.operation.status = "completed";
         result2.success = true;
@@ -113463,8 +113276,6 @@ class PushCommand {
         recoverable: false
       });
       throw error;
-    } finally {
-      await this.connectionManager.closeConnection();
     }
     return result2;
   }
@@ -113584,20 +113395,6 @@ ${"=".repeat(80)}`);
           conflictType: "missing-source"
         };
       }
-      const wpModified = new Date(wpPost.modified);
-      const lastPushed = mdxFile.frontmatter.lastPushed ? new Date(mdxFile.frontmatter.lastPushed) : null;
-      if (lastPushed && wpModified > lastPushed) {
-        const tolerance = 5000;
-        if (wpModified.getTime() - lastPushed.getTime() > tolerance) {
-          return {
-            postId: mdxFile.frontmatter.postId,
-            localPath: mdxFile.path,
-            wordpressPost: wpPost,
-            localFile: mdxFile,
-            conflictType: "wordpress-newer"
-          };
-        }
-      }
       return null;
     } catch (error) {
       logger.warn(`Could not check for conflicts on post ${mdxFile.frontmatter.postId}: ${error.message}`);
@@ -113630,31 +113427,15 @@ ${"=".repeat(80)}`);
       }
       let frontmatter = frontmatterMatch[1];
       const postId = wpPost.id;
-      const modified = wpPost.modified || new Date().toISOString();
-      const lastPushed = new Date().toISOString();
-      if (frontmatter.includes("postId:")) {
-        frontmatter = frontmatter.replace(/postId:\s*\d*/, `postId: ${postId}`);
-      } else {
+      if (!frontmatter.includes("postId:")) {
         frontmatter = `${frontmatter}
 postId: ${postId}`;
-      }
-      if (frontmatter.includes("modified:")) {
-        frontmatter = frontmatter.replace(/modified:\s*"[^"]*"/, `modified: "${modified}"`);
-      } else {
-        frontmatter = `${frontmatter}
-modified: "${modified}"`;
-      }
-      if (frontmatter.includes("lastPushed:")) {
-        frontmatter = frontmatter.replace(/lastPushed:\s*"[^"]*"/, `lastPushed: "${lastPushed}"`);
-      } else {
-        frontmatter = `${frontmatter}
-lastPushed: "${lastPushed}"`;
-      }
-      const updatedContent = content4.replace(/^---\n([\s\S]*?)\n---/, `---
+        const updatedContent = content4.replace(/^---\n([\s\S]*?)\n---/, `---
 ${frontmatter}
 ---`);
-      fs5.writeFileSync(filePath2, updatedContent, "utf8");
-      logger.debug(`Updated ${filePath2} with sync timestamps`);
+        fs5.writeFileSync(filePath2, updatedContent, "utf8");
+        logger.debug(`Added postId to ${filePath2}`);
+      }
     } catch (error) {
       logger.warn(`Failed to update MDX file after push: ${error.message}`);
     }
@@ -113701,6 +113482,15 @@ class ChangeQueue extends EventEmitter3 {
     });
     this.scheduleFlush();
   }
+  queueTemplatePartChange(partPath, eventType) {
+    const key = `templatePart:${partPath}`;
+    this.pendingChanges.set(key, {
+      type: "templatePart",
+      filePath: partPath,
+      eventType
+    });
+    this.scheduleFlush();
+  }
   queuePageChange(pagePath, eventType) {
     const key = `page:${pagePath}`;
     this.pendingChanges.set(key, {
@@ -113733,6 +113523,7 @@ class ChangeQueue extends EventEmitter3 {
   buildBatch() {
     const blocks = new Map;
     const templates = [];
+    const templateParts = [];
     const pages = [];
     const deletedBlocks = [];
     for (const change of this.pendingChanges.values()) {
@@ -113758,6 +113549,11 @@ class ChangeQueue extends EventEmitter3 {
             templates.push(change.filePath);
           }
           break;
+        case "templatePart":
+          if (change.eventType !== "unlink") {
+            templateParts.push(change.filePath);
+          }
+          break;
         case "page":
           if (change.eventType !== "unlink") {
             pages.push(change.filePath);
@@ -113768,6 +113564,7 @@ class ChangeQueue extends EventEmitter3 {
     return {
       blocks,
       templates,
+      templateParts,
       pages,
       deletedBlocks,
       triggeredAt: Date.now()
@@ -114120,10 +113917,16 @@ class DevModeUI {
     }
   }
   showWatching() {
-    console.log("");
-    logger.info("\uD83D\uDC40 Watching for changes...");
-    logger.info("   Press Ctrl+C to stop");
-    console.log("");
+    console.log(`
+` + "─".repeat(50));
+    console.log("✅ Dev mode ready! Watching for changes...");
+    console.log("─".repeat(50));
+    console.log("  • Edit blocks → auto-rebuild + cascade updates");
+    console.log("  • Edit templates → auto-rebuild HTML");
+    console.log("  • Edit pages → auto-push to WordPress");
+    console.log("  • Press Ctrl+C to stop");
+    console.log("─".repeat(50) + `
+`);
   }
   showInitialBuildStart(blockCount, cached) {
     if (cached > 0) {
@@ -114866,8 +114669,8 @@ var watch = (paths, options) => {
 var $watch = watch;
 
 // src/dev/dev-mode-orchestrator.ts
-import * as path16 from "path";
-import * as fs14 from "fs";
+import * as path17 from "path";
+import * as fs15 from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/build/block-scanner.ts
@@ -115427,40 +115230,49 @@ import * as fs10 from "fs";
 import * as path12 from "path";
 class DependencyTracker {
   blockToTemplates = new Map;
+  blockToTemplateParts = new Map;
   blockToPages = new Map;
   fileToBlocks = new Map;
   blockLocalImports = new Map;
-  async scanDependencies(templatesDir, contentDir) {
+  async scanDependencies(templatesDir, contentDir, templatePartsDir) {
     this.blockToTemplates.clear();
+    this.blockToTemplateParts.clear();
     this.blockToPages.clear();
     this.fileToBlocks.clear();
     if (templatesDir && fs10.existsSync(templatesDir)) {
-      await this.scanTemplates(templatesDir);
+      await this.scanDirectory(templatesDir, "template");
+    }
+    if (templatePartsDir && fs10.existsSync(templatePartsDir)) {
+      await this.scanDirectory(templatePartsDir, "templatePart");
     }
     if (fs10.existsSync(contentDir)) {
       await this.scanPages(contentDir);
     }
     const stats = this.getStats();
-    logger.debug(`Dependency scan complete: ${stats.totalTemplates} templates, ${stats.totalPages} pages, ${stats.totalBlocks} unique blocks`);
+    logger.debug(`Dependency scan complete: ${stats.totalTemplates} templates, ${stats.totalTemplateParts} parts, ${stats.totalPages} pages, ${stats.totalBlocks} unique blocks`);
   }
-  async scanTemplates(templatesDir) {
-    const pattern = path12.join(templatesDir, "**/*.mdx");
+  async scanDirectory(dir, type) {
+    const pattern = path12.join(dir, "**/*.mdx");
     const files = await glob(pattern);
+    const blockMap = type === "template" ? this.blockToTemplates : this.blockToTemplateParts;
     for (const filePath2 of files) {
       try {
         const blocks = await this.extractBlocksFromFile(filePath2);
         this.fileToBlocks.set(filePath2, new Set(blocks));
         for (const blockName of blocks) {
-          if (!this.blockToTemplates.has(blockName)) {
-            this.blockToTemplates.set(blockName, new Set);
+          if (!blockMap.has(blockName)) {
+            blockMap.set(blockName, new Set);
           }
-          this.blockToTemplates.get(blockName).add(filePath2);
+          blockMap.get(blockName).add(filePath2);
         }
       } catch (error) {
-        logger.warn(`Failed to scan template ${filePath2}: ${error}`);
+        logger.warn(`Failed to scan ${type} ${filePath2}: ${error}`);
       }
     }
-    logger.debug(`Scanned ${files.length} templates`);
+    logger.debug(`Scanned ${files.length} ${type}s`);
+  }
+  async scanTemplates(templatesDir) {
+    await this.scanDirectory(templatesDir, "template");
   }
   async scanPages(contentDir) {
     const patterns = [
@@ -115547,12 +115359,16 @@ class DependencyTracker {
   getDependentTemplates(blockName) {
     return Array.from(this.blockToTemplates.get(blockName) || []);
   }
+  getDependentTemplateParts(blockName) {
+    return Array.from(this.blockToTemplateParts.get(blockName) || []);
+  }
   getDependentPages(blockName) {
     return Array.from(this.blockToPages.get(blockName) || []);
   }
   getDependentFiles(blockName) {
     return [
       ...this.getDependentTemplates(blockName),
+      ...this.getDependentTemplateParts(blockName),
       ...this.getDependentPages(blockName)
     ];
   }
@@ -115560,16 +115376,21 @@ class DependencyTracker {
     return Array.from(this.blockLocalImports.get(blockFilePath) || []);
   }
   hasDependents(blockNames) {
-    return blockNames.some((name2) => (this.blockToTemplates.get(name2)?.size || 0) > 0 || (this.blockToPages.get(name2)?.size || 0) > 0);
+    return blockNames.some((name2) => (this.blockToTemplates.get(name2)?.size || 0) > 0 || (this.blockToTemplateParts.get(name2)?.size || 0) > 0 || (this.blockToPages.get(name2)?.size || 0) > 0);
   }
   getCascade(changedBlocks) {
     const templates = new Set;
+    const templateParts = new Set;
     const pages = new Set;
     for (const blockName of changedBlocks) {
       const blockTemplates = this.blockToTemplates.get(blockName);
       if (blockTemplates) {
         blockTemplates.forEach((t) => templates.add(t));
       }
+      const blockParts = this.blockToTemplateParts.get(blockName);
+      if (blockParts) {
+        blockParts.forEach((p) => templateParts.add(p));
+      }
       const blockPages = this.blockToPages.get(blockName);
       if (blockPages) {
         blockPages.forEach((p) => pages.add(p));
@@ -115577,9 +115398,64 @@ class DependencyTracker {
     }
     return {
       templates: Array.from(templates),
+      templateParts: Array.from(templateParts),
       pages: Array.from(pages)
     };
   }
+  getCascadeForTypes(changedBlocks, types4) {
+    const result2 = {};
+    for (const type of types4) {
+      result2[type] = [];
+    }
+    for (const blockName of changedBlocks) {
+      if (types4.includes("template")) {
+        const blockTemplates = this.blockToTemplates.get(blockName);
+        if (blockTemplates) {
+          result2.template = [
+            ...new Set([
+              ...result2.template || [],
+              ...Array.from(blockTemplates)
+            ])
+          ];
+        }
+      }
+      if (types4.includes("templatePart")) {
+        const blockParts = this.blockToTemplateParts.get(blockName);
+        if (blockParts) {
+          result2.templatePart = [
+            ...new Set([
+              ...result2.templatePart || [],
+              ...Array.from(blockParts)
+            ])
+          ];
+        }
+      }
+      if (types4.includes("page")) {
+        const blockPages = this.blockToPages.get(blockName);
+        if (blockPages) {
+          result2.page = [
+            ...new Set([...result2.page || [], ...Array.from(blockPages)])
+          ];
+        }
+      }
+    }
+    return result2;
+  }
+  getAffectedArtifactTypes(changedBlocks) {
+    const types4 = [];
+    for (const blockName of changedBlocks) {
+      if (!types4.includes("template") && (this.blockToTemplates.get(blockName)?.size || 0) > 0) {
+        types4.push("template");
+      }
+      if (!types4.includes("templatePart") && (this.blockToTemplateParts.get(blockName)?.size || 0) > 0) {
+        types4.push("templatePart");
+      }
+      if (!types4.includes("page") && (this.blockToPages.get(blockName)?.size || 0) > 0) {
+        types4.push("page");
+      }
+    }
+    return types4;
+  }
   findBlockForImport(importPath) {
     for (const [blockPath, imports] of this.blockLocalImports) {
       if (imports.has(importPath)) {
@@ -115594,6 +115470,8 @@ class DependencyTracker {
       for (const blockName of oldBlocks) {
         if (type === "template") {
           this.blockToTemplates.get(blockName)?.delete(filePath2);
+        } else if (type === "templatePart") {
+          this.blockToTemplateParts.get(blockName)?.delete(filePath2);
         } else {
           this.blockToPages.get(blockName)?.delete(filePath2);
         }
@@ -115608,6 +115486,11 @@ class DependencyTracker {
             this.blockToTemplates.set(blockName, new Set);
           }
           this.blockToTemplates.get(blockName).add(filePath2);
+        } else if (type === "templatePart") {
+          if (!this.blockToTemplateParts.has(blockName)) {
+            this.blockToTemplateParts.set(blockName, new Set);
+          }
+          this.blockToTemplateParts.get(blockName).add(filePath2);
         } else {
           if (!this.blockToPages.has(blockName)) {
             this.blockToPages.set(blockName, new Set);
@@ -115624,6 +115507,7 @@ class DependencyTracker {
     if (blocks) {
       for (const blockName of blocks) {
         this.blockToTemplates.get(blockName)?.delete(filePath2);
+        this.blockToTemplateParts.get(blockName)?.delete(filePath2);
         this.blockToPages.get(blockName)?.delete(filePath2);
       }
     }
@@ -115637,23 +115521,33 @@ class DependencyTracker {
       if (templates.size > 0)
         blocksWithDependents++;
     }
+    for (const [blockName, parts] of this.blockToTemplateParts) {
+      allBlocks.add(blockName);
+      if (parts.size > 0 && !this.blockToTemplates.get(blockName)?.size) {
+        blocksWithDependents++;
+      }
+    }
     for (const [blockName, pages] of this.blockToPages) {
       allBlocks.add(blockName);
-      if (pages.size > 0 && !this.blockToTemplates.get(blockName)?.size) {
+      if (pages.size > 0 && !this.blockToTemplates.get(blockName)?.size && !this.blockToTemplateParts.get(blockName)?.size) {
         blocksWithDependents++;
       }
     }
     let totalTemplates = 0;
+    let totalTemplateParts = 0;
     let totalPages = 0;
     for (const filePath2 of this.fileToBlocks.keys()) {
       if (filePath2.includes("/templates/") || filePath2.includes("\\templates\\")) {
         totalTemplates++;
+      } else if (filePath2.includes("/parts/") || filePath2.includes("\\parts\\")) {
+        totalTemplateParts++;
       } else {
         totalPages++;
       }
     }
     return {
       totalTemplates,
+      totalTemplateParts,
       totalPages,
       totalBlocks: allBlocks.size,
       blocksWithDependents
@@ -115668,6 +115562,14 @@ class DependencyTracker {
       }
     }
     logger.info(`
+=== Block → Template Parts ===`);
+    for (const [blockName, parts] of this.blockToTemplateParts) {
+      if (parts.size > 0) {
+        const names = Array.from(parts).map((p) => path12.basename(p));
+        logger.info(`${blockName}: [${names.join(", ")}]`);
+      }
+    }
+    logger.info(`
 === Block → Pages ===`);
     for (const [blockName, pages] of this.blockToPages) {
       if (pages.size > 0) {
@@ -115679,6 +115581,7 @@ class DependencyTracker {
     logger.info(`
 === Stats ===`);
     logger.info(`Templates: ${stats.totalTemplates}`);
+    logger.info(`Template Parts: ${stats.totalTemplateParts}`);
     logger.info(`Pages: ${stats.totalPages}`);
     logger.info(`Unique blocks: ${stats.totalBlocks}`);
     logger.info(`Blocks with dependents: ${stats.blocksWithDependents}`);
@@ -116006,10 +115909,359 @@ add_action('enqueue_block_assets', 'wordpress_flow_enqueue_block_scripts');
     );`;
   }
 }
+
+// src/env/docker-env-manager.ts
+import { execSync } from "child_process";
+import * as fs14 from "fs";
+import * as path16 from "path";
+class DockerEnvManager {
+  projectName;
+  workspaceDir;
+  config;
+  containerNames;
+  constructor(options) {
+    this.projectName = this.sanitizeProjectName(options.projectName);
+    this.workspaceDir = options.workspaceDir;
+    this.config = options.config;
+    this.containerNames = {
+      wordpress: `${this.projectName}-wordpress`,
+      mysql: `${this.projectName}-mysql`
+    };
+  }
+  sanitizeProjectName(name2) {
+    return name2.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  }
+  async checkDocker() {
+    try {
+      execSync("docker info", { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getContainerStatus() {
+    const status = {
+      wordpress: "not-found",
+      mysql: "not-found"
+    };
+    try {
+      const wpStatus = execSync(`docker inspect -f '{{.State.Status}}' ${this.containerNames.wordpress} 2>/dev/null`, { encoding: "utf8" }).trim();
+      status.wordpress = wpStatus === "running" ? "running" : "stopped";
+    } catch {
+      status.wordpress = "not-found";
+    }
+    try {
+      const mysqlStatus = execSync(`docker inspect -f '{{.State.Status}}' ${this.containerNames.mysql} 2>/dev/null`, { encoding: "utf8" }).trim();
+      status.mysql = mysqlStatus === "running" ? "running" : "stopped";
+    } catch {
+      status.mysql = "not-found";
+    }
+    return status;
+  }
+  async start() {
+    const dockerInstalled = await this.checkDocker();
+    if (!dockerInstalled) {
+      throw new Error(`Docker is not installed or not running.
+
+` + `To install Docker:
+` + `  • macOS: Download from https://docker.com/products/docker-desktop
+` + "  • Linux: Run `curl -fsSL https://get.docker.com | sh`\n" + `  • Windows: Download from https://docker.com/products/docker-desktop
+
+` + "After installing, make sure Docker Desktop is running.");
+    }
+    const status = await this.getContainerStatus();
+    let isFirstRun = false;
+    if (status.wordpress === "not-found" || status.mysql === "not-found") {
+      logger.info("\uD83D\uDC33 Creating Docker containers...");
+      await this.createContainers();
+      isFirstRun = true;
+    } else if (status.wordpress === "stopped" || status.mysql === "stopped") {
+      logger.info("\uD83D\uDC33 Starting existing containers...");
+      await this.startContainers();
+    } else {
+      logger.info("\uD83D\uDC33 Docker containers already running");
+    }
+    await this.waitForWordPress();
+    const wordpressUrl = this.getWordPressUrl();
+    return { wordpressUrl, isFirstRun };
+  }
+  async createContainers() {
+    try {
+      execSync(`docker network create ${this.projectName}-network 2>/dev/null`, {
+        stdio: "pipe"
+      });
+    } catch {}
+    const themeDir = path16.resolve(this.workspaceDir, this.config.paths.theme);
+    const themeName = path16.basename(themeDir);
+    logger.info("  Starting MySQL...");
+    const mysqlVolume = `-v ${this.projectName}-mysql-data:/var/lib/mysql`;
+    const mysqlPort = this.config.dev.databasePort ? `-p ${this.config.dev.databasePort}:3306` : "";
+    execSync(`docker run -d         --name ${this.containerNames.mysql}         --network ${this.projectName}-network         ${mysqlVolume}         ${mysqlPort}         -e MYSQL_ROOT_PASSWORD=password         -e MYSQL_DATABASE=wordpress         -e MYSQL_USER=wordpress         -e MYSQL_PASSWORD=wordpress         mysql:8.0`, { stdio: "pipe" });
+    await this.waitForMySQL();
+    logger.info("  Starting WordPress...");
+    const uploadsVolume = `-v ${this.projectName}-uploads:/var/www/html/wp-content/uploads`;
+    let pluginMounts = "";
+    const pluginsDir = path16.resolve(this.workspaceDir, this.config.paths.plugins);
+    if (fs14.existsSync(pluginsDir)) {
+      const pluginFolders = fs14.readdirSync(pluginsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      for (const pluginName of pluginFolders) {
+        const pluginPath = path16.join(pluginsDir, pluginName);
+        pluginMounts += ` -v "${pluginPath}:/var/www/html/wp-content/plugins/${pluginName}"`;
+      }
+      if (pluginFolders.length > 0) {
+        logger.info(`  Mounting ${pluginFolders.length} local plugin(s): ${pluginFolders.join(", ")}`);
+      }
+    }
+    const wpImage = this.config.dev.wordpressVersion === "latest" ? `wordpress:php${this.config.dev.phpVersion}` : `wordpress:${this.config.dev.wordpressVersion}-php${this.config.dev.phpVersion}`;
+    execSync(`docker run -d         --name ${this.containerNames.wordpress}         --network ${this.projectName}-network         -p ${this.config.dev.port}:80         -v "${themeDir}:/var/www/html/wp-content/themes/${themeName}"         ${pluginMounts}         ${uploadsVolume}         -e WORDPRESS_DB_HOST=${this.containerNames.mysql}         -e WORDPRESS_DB_USER=wordpress         -e WORDPRESS_DB_PASSWORD=wordpress         -e WORDPRESS_DB_NAME=wordpress         ${wpImage}`, { stdio: "pipe" });
+  }
+  async startContainers() {
+    execSync(`docker start ${this.containerNames.mysql}`, { stdio: "pipe" });
+    await this.waitForMySQL();
+    execSync(`docker start ${this.containerNames.wordpress}`, {
+      stdio: "pipe"
+    });
+  }
+  async stop() {
+    logger.info("\uD83D\uDC33 Stopping Docker containers...");
+    try {
+      execSync(`docker stop ${this.containerNames.wordpress}`, {
+        stdio: "pipe"
+      });
+    } catch {}
+    try {
+      execSync(`docker stop ${this.containerNames.mysql}`, { stdio: "pipe" });
+    } catch {}
+  }
+  async waitForMySQL() {
+    const maxAttempts = 30;
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+      try {
+        execSync(`docker exec ${this.containerNames.mysql} mysqladmin ping -h localhost -u root -ppassword 2>/dev/null`, { stdio: "pipe" });
+        return;
+      } catch {
+        attempts++;
+        await this.sleep(1000);
+      }
+    }
+    throw new Error("MySQL failed to start within 30 seconds");
+  }
+  async waitForMySQLReady() {
+    const maxAttempts = 30;
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+      try {
+        execSync(`docker exec ${this.containerNames.mysql} mysql -h 127.0.0.1 -u wordpress -pwordpress -e "SELECT 1" 2>/dev/null`, { stdio: "pipe" });
+        return;
+      } catch {
+        attempts++;
+        await this.sleep(1000);
+      }
+    }
+    throw new Error("MySQL failed to accept connections within 30 seconds");
+  }
+  async waitForWordPress() {
+    const maxAttempts = 60;
+    let attempts = 0;
+    logger.info("  Waiting for WordPress...");
+    while (attempts < maxAttempts) {
+      try {
+        const response = execSync(`curl -s -o /dev/null -w "%{http_code}" http://localhost:${this.config.dev.port}`, { encoding: "utf8", stdio: "pipe" }).trim();
+        if (response.length > 0) {
+          return;
+        }
+      } catch {}
+      attempts++;
+      await this.sleep(1000);
+    }
+    throw new Error("WordPress failed to start within 60 seconds");
+  }
+  async installWPCLI() {
+    logger.info("  Installing WP-CLI...");
+    try {
+      execSync(`docker exec ${this.containerNames.wordpress} sh -c "curl -O https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar && chmod +x wp-cli.phar && mv wp-cli.phar /usr/local/bin/wp"`, { stdio: "pipe" });
+    } catch (error) {
+      throw new Error(`Failed to install WP-CLI: ${error.message}`);
+    }
+  }
+  async hasWPCLI() {
+    try {
+      execSync(`docker exec ${this.containerNames.wordpress} wp --version --allow-root 2>/dev/null`, { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async isWordPressInstalled() {
+    if (!await this.hasWPCLI()) {
+      await this.installWPCLI();
+    }
+    try {
+      execSync(`docker exec ${this.containerNames.wordpress} wp core is-installed --allow-root 2>/dev/null`, { stdio: "pipe", encoding: "utf8" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async installWordPress() {
+    logger.info("  Installing WordPress...");
+    const siteUrl = this.getWordPressUrl();
+    const themeName = path16.basename(path16.resolve(this.workspaceDir, this.config.paths.theme));
+    execSync(`docker exec ${this.containerNames.wordpress} wp core install         --url="${siteUrl}"         --title="Development Site"         --admin_user=admin         --admin_password=password         --admin_email=admin@example.com         --skip-email         --allow-root`, { stdio: "pipe" });
+    logger.info(`  Activating theme: ${themeName}...`);
+    try {
+      execSync(`docker exec ${this.containerNames.wordpress} wp theme activate ${themeName} --allow-root`, { stdio: "pipe" });
+    } catch (error) {
+      logger.warn(`  Could not activate theme: ${themeName}`);
+    }
+    execSync(`docker exec ${this.containerNames.wordpress} wp rewrite structure '/%postname%/' --allow-root`, { stdio: "pipe" });
+  }
+  async installPlugins() {
+    if (this.config.dev.plugins.length === 0)
+      return;
+    logger.info("  Installing plugins...");
+    for (const plugin of this.config.dev.plugins) {
+      try {
+        if (plugin.startsWith("./") || plugin.startsWith("/")) {
+          const pluginPath = path16.resolve(this.workspaceDir, plugin);
+          const pluginName = path16.basename(pluginPath);
+          execSync(`docker cp "${pluginPath}" ${this.containerNames.wordpress}:/var/www/html/wp-content/plugins/${pluginName}`, { stdio: "pipe" });
+          execSync(`docker exec ${this.containerNames.wordpress} wp plugin activate ${pluginName} --allow-root`, { stdio: "pipe" });
+        } else {
+          execSync(`docker exec ${this.containerNames.wordpress} wp plugin install ${plugin} --activate --allow-root`, { stdio: "pipe" });
+        }
+        logger.info(`    ✓ ${plugin}`);
+      } catch (error) {
+        logger.warn(`    ✗ Failed to install: ${plugin}`);
+      }
+    }
+  }
+  async importSqlDump() {
+    if (!this.config.dev.sqlDump)
+      return;
+    const sqlPath = path16.resolve(this.workspaceDir, this.config.dev.sqlDump);
+    if (!fs14.existsSync(sqlPath)) {
+      logger.warn(`  SQL dump not found: ${sqlPath}`);
+      return;
+    }
+    logger.info("  Importing SQL dump...");
+    await this.waitForMySQLReady();
+    execSync(`docker cp "${sqlPath}" ${this.containerNames.mysql}:/tmp/dump.sql`, { stdio: "pipe" });
+    execSync(`docker exec ${this.containerNames.mysql} sh -c "mysql -h 127.0.0.1 -u wordpress -pwordpress wordpress < /tmp/dump.sql"`, { stdio: "pipe" });
+    const siteUrl = this.getWordPressUrl();
+    execSync(`docker exec ${this.containerNames.wordpress} wp option update siteurl "${siteUrl}" --allow-root`, { stdio: "pipe" });
+    execSync(`docker exec ${this.containerNames.wordpress} wp option update home "${siteUrl}" --allow-root`, { stdio: "pipe" });
+    await this.reactivatePlugins();
+    logger.info("    ✓ SQL dump imported");
+  }
+  async reactivatePlugins() {
+    try {
+      const pluginsOutput = execSync(`docker exec ${this.containerNames.wordpress} wp plugin list --field=name --status=inactive --allow-root 2>/dev/null`, { encoding: "utf8", stdio: "pipe" }).trim();
+      if (!pluginsOutput)
+        return;
+      const inactivePlugins = pluginsOutput.split(`
+`).filter((p) => p.trim());
+      if (inactivePlugins.length === 0)
+        return;
+      logger.info("  Reactivating plugins...");
+      for (const plugin of inactivePlugins) {
+        try {
+          execSync(`docker exec ${this.containerNames.wordpress} wp plugin activate ${plugin} --allow-root`, { stdio: "pipe" });
+          logger.info(`    ✓ ${plugin}`);
+        } catch {
+          logger.warn(`    ✗ Could not activate: ${plugin}`);
+        }
+      }
+    } catch {}
+  }
+  async exportSqlDump(outputPath) {
+    const status = await this.getContainerStatus();
+    if (status.mysql !== "running") {
+      throw new Error("MySQL container is not running. Start the environment first with `wordpress-flow dev`");
+    }
+    logger.info("  Exporting database...");
+    const sqlContent = execSync(`docker exec ${this.containerNames.mysql} mysqldump -h 127.0.0.1 -u wordpress -pwordpress wordpress 2>/dev/null`, { encoding: "utf8", maxBuffer: 50 * 1024 * 1024 });
+    const resolvedPath = path16.resolve(this.workspaceDir, outputPath);
+    const dir = path16.dirname(resolvedPath);
+    if (!fs14.existsSync(dir)) {
+      fs14.mkdirSync(dir, { recursive: true });
+    }
+    fs14.writeFileSync(resolvedPath, sqlContent, "utf8");
+    logger.info(`    ✓ Database exported to ${outputPath}`);
+  }
+  async importSqlDumpFromFile(inputPath) {
+    const status = await this.getContainerStatus();
+    if (status.mysql !== "running") {
+      throw new Error("MySQL container is not running. Start the environment first with `wordpress-flow dev`");
+    }
+    const sqlPath = path16.resolve(this.workspaceDir, inputPath);
+    if (!fs14.existsSync(sqlPath)) {
+      throw new Error(`SQL dump not found: ${sqlPath}`);
+    }
+    logger.info("  Importing SQL dump...");
+    await this.waitForMySQLReady();
+    execSync(`docker cp "${sqlPath}" ${this.containerNames.mysql}:/tmp/dump.sql`, { stdio: "pipe" });
+    execSync(`docker exec ${this.containerNames.mysql} sh -c "mysql -h 127.0.0.1 -u wordpress -pwordpress wordpress < /tmp/dump.sql"`, { stdio: "pipe" });
+    if (!await this.hasWPCLI()) {
+      await this.installWPCLI();
+    }
+    const siteUrl = this.getWordPressUrl();
+    try {
+      execSync(`docker exec ${this.containerNames.wordpress} wp option update siteurl "${siteUrl}" --allow-root`, { stdio: "pipe" });
+      execSync(`docker exec ${this.containerNames.wordpress} wp option update home "${siteUrl}" --allow-root`, { stdio: "pipe" });
+    } catch {
+      logger.warn("  Could not update site URLs (WordPress may not be fully installed)");
+    }
+    logger.info("    ✓ SQL dump imported");
+  }
+  getDatabaseConfig() {
+    return {
+      host: "127.0.0.1",
+      port: this.config.dev.databasePort,
+      database: "wordpress",
+      username: "wordpress",
+      password: "wordpress"
+    };
+  }
+  getWordPressUrl() {
+    return `http://localhost:${this.config.dev.port}`;
+  }
+  sleep(ms) {
+    return new Promise((resolve6) => setTimeout(resolve6, ms));
+  }
+  async cleanup() {
+    logger.info("\uD83E\uDDF9 Cleaning up Docker environment...");
+    try {
+      execSync(`docker rm -f ${this.containerNames.wordpress}`, {
+        stdio: "pipe"
+      });
+    } catch {}
+    try {
+      execSync(`docker rm -f ${this.containerNames.mysql}`, { stdio: "pipe" });
+    } catch {}
+    try {
+      execSync(`docker network rm ${this.projectName}-network`, {
+        stdio: "pipe"
+      });
+    } catch {}
+    try {
+      execSync(`docker volume rm ${this.projectName}-mysql-data`, {
+        stdio: "pipe"
+      });
+    } catch {}
+    try {
+      execSync(`docker volume rm ${this.projectName}-uploads`, {
+        stdio: "pipe"
+      });
+    } catch {}
+    logger.info("  ✓ Cleanup complete");
+  }
+}
 // package.json
 var package_default = {
   name: "@wordpress-flow/cli",
-  version: "1.1.3",
+  version: "1.2.0",
   type: "module",
   description: "TypeScript-based WordPress block creation system",
   main: "dist/index.js",
@@ -116062,7 +116314,7 @@ var package_default = {
 
 // src/dev/dev-mode-orchestrator.ts
 var __filename2 = fileURLToPath4(import.meta.url);
-var __dirname2 = path16.dirname(__filename2);
+var __dirname2 = path17.dirname(__filename2);
 
 class DevModeOrchestrator {
   configManager;
@@ -116080,6 +116332,7 @@ class DevModeOrchestrator {
   phpGenerator;
   blockRegistry;
   pushCommand;
+  dockerEnvManager;
   options;
   watchers = [];
   isRunning = false;
@@ -116087,6 +116340,8 @@ class DevModeOrchestrator {
   outputDir;
   templatesDir;
   templatesOutputDir;
+  templatePartsDir;
+  templatePartsOutputDir;
   contentDir;
   webpackConfig;
   scriptsPath;
@@ -116102,6 +116357,7 @@ class DevModeOrchestrator {
       autoPush: true,
       buildTemplates: true,
       verbose: false,
+      skipEnv: false,
       ...options
     };
     this.configManager = ConfigManager.getInstance();
@@ -116122,16 +116378,30 @@ class DevModeOrchestrator {
     });
   }
   async start() {
-    logger.progress("Starting dev mode...");
+    console.log(`
+\uD83D\uDE80 Starting dev mode...
+`);
     try {
+      console.log("\uD83D\uDCCB Loading configuration...");
       await this.initializeConfig();
+      const config = this.configManager.getConfig();
+      if (!this.options.skipEnv) {
+        console.log("\uD83D\uDC33 Setting up Docker environment...");
+        await this.startDockerEnvironment();
+      }
+      console.log("⚙️  Initializing build system...");
       this.initializeManagers();
       if (this.options.autoPush) {
+        console.log("\uD83D\uDD0C Connecting to WordPress...");
         await this.connectWordPress();
       }
+      console.log("\uD83D\uDD0D Scanning blocks...");
       const blocks = await this.scanBlocks();
+      console.log("\uD83D\uDD17 Analyzing dependencies...");
       await this.scanDependencies();
+      console.log("\uD83D\uDD28 Running initial build...");
       await this.performInitialBuild(blocks);
+      console.log("\uD83D\uDC40 Starting file watchers...");
       this.startWatchers();
       this.isRunning = true;
       this.ui.showWatching();
@@ -116142,23 +116412,62 @@ class DevModeOrchestrator {
       throw error;
     }
   }
-  async initializeConfig() {
-    const config2 = this.configManager.getConfig();
-    this.blocksDir = this.configManager.resolvePath(config2.build?.blocksDir || "./theme/blocks");
-    this.outputDir = this.configManager.resolvePath(config2.build?.outputDir || "./theme/dist");
-    if (config2.build?.webpackConfig) {
-      this.webpackConfig = this.configManager.resolvePath(config2.build.webpackConfig);
-    } else {
-      this.webpackConfig = path16.join(__dirname2, "..", "webpack.config.cjs");
+  async startDockerEnvironment() {
+    const config = this.configManager.getConfig();
+    const packageJsonPath = path17.join(this.configManager.getConfigDir(), "package.json");
+    let projectName = "wordpress-project";
+    if (fs15.existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs15.readFileSync(packageJsonPath, "utf8"));
+        projectName = pkg.name || projectName;
+      } catch {}
     }
-    this.scriptsPath = config2.build?.scriptsPath ? this.configManager.resolvePath(config2.build.scriptsPath) : undefined;
-    this.contentDir = this.configManager.resolvePath(config2.paths.mdxOutputDir);
-    if (config2.templates) {
-      this.templatesDir = this.configManager.resolvePath(config2.templates.templatesDir);
-      this.templatesOutputDir = this.configManager.resolvePath(config2.templates.outputDir);
+    this.dockerEnvManager = new DockerEnvManager({
+      projectName,
+      workspaceDir: this.configManager.getConfigDir(),
+      config
+    });
+    try {
+      const { wordpressUrl, isFirstRun } = await this.dockerEnvManager.start();
+      if (isFirstRun) {
+        const isInstalled = await this.dockerEnvManager.isWordPressInstalled();
+        if (!isInstalled) {
+          await this.dockerEnvManager.importSqlDump();
+          const isInstalledAfterImport = await this.dockerEnvManager.isWordPressInstalled();
+          if (!isInstalledAfterImport) {
+            await this.dockerEnvManager.installWordPress();
+          }
+        }
+        await this.dockerEnvManager.installPlugins();
+      }
+      const dbConfig = this.dockerEnvManager.getDatabaseConfig();
+      this.configManager.setDatabaseConnection(dbConfig);
+      logger.success(`WordPress running at ${wordpressUrl}`);
+      logger.info(`  Admin: ${wordpressUrl}/wp-admin (admin / password)`);
+      if (config.dev.databasePort) {
+        logger.info(`  Database: 127.0.0.1:${config.dev.databasePort} (wordpress / wordpress)`);
+      }
+    } catch (error) {
+      const errorMessage = error.message;
+      console.error(`
+❌ ${errorMessage}
+`);
+      process.exit(1);
     }
-    if (!fs14.existsSync(this.outputDir)) {
-      fs14.mkdirSync(this.outputDir, { recursive: true });
+  }
+  async initializeConfig() {
+    const config = this.configManager.getConfig();
+    this.blocksDir = this.configManager.resolvePath(config.paths.blocks);
+    this.outputDir = this.configManager.resolvePath(config.paths.dist);
+    this.webpackConfig = path17.join(__dirname2, "..", "webpack.config.cjs");
+    this.scriptsPath = this.configManager.resolvePath(config.paths.scripts);
+    this.contentDir = this.configManager.resolvePath(config.paths.content);
+    this.templatesDir = this.configManager.resolvePath(config.paths.templates);
+    this.templatesOutputDir = this.configManager.resolvePath(config.paths.templatesOutput);
+    this.templatePartsDir = this.configManager.resolvePath(config.paths.templateParts);
+    this.templatePartsOutputDir = this.configManager.resolvePath(config.paths.partsOutput);
+    if (!fs15.existsSync(this.outputDir)) {
+      fs15.mkdirSync(this.outputDir, { recursive: true });
     }
   }
   initializeManagers() {
@@ -116179,8 +116488,18 @@ class DevModeOrchestrator {
   }
   async connectWordPress() {
     try {
-      const config2 = this.configManager.getConfig();
-      await this.connectionManager.createConnection(config2.wordpress);
+      const config = this.configManager.getConfig();
+      const dbConfig = config.database || this.dockerEnvManager?.getDatabaseConfig();
+      if (!dbConfig) {
+        throw new Error("No database connection available. Make sure Docker environment is running.");
+      }
+      const wpConfig = {
+        type: "database",
+        wordpressUrl: this.configManager.getWordPressUrl(),
+        database: dbConfig
+      };
+      logger.info(`  Using database: ${dbConfig.host}:${dbConfig.port}`);
+      await this.connectionManager.createConnection(wpConfig);
       this.pushCommand = new PushCommand(this.blockRegistry);
       logger.success("WordPress connection established");
     } catch (error) {
@@ -116190,7 +116509,7 @@ class DevModeOrchestrator {
     }
   }
   async scanBlocks() {
-    if (!fs14.existsSync(this.blocksDir)) {
+    if (!fs15.existsSync(this.blocksDir)) {
       logger.warn(`Blocks directory not found: ${this.blocksDir}`);
       return [];
     }
@@ -116208,9 +116527,9 @@ class DevModeOrchestrator {
     return blocks;
   }
   async scanDependencies() {
-    await this.dependencyTracker.scanDependencies(this.templatesDir, this.contentDir);
+    await this.dependencyTracker.scanDependencies(this.templatesDir, this.contentDir, this.templatePartsDir);
     const stats = this.dependencyTracker.getStats();
-    this.ui.showDependencyScan(stats.totalTemplates, stats.totalPages, stats.totalBlocks);
+    this.ui.showDependencyScan(stats.totalTemplates + stats.totalTemplateParts, stats.totalPages, stats.totalBlocks);
   }
   async performInitialBuild(blocks) {
     const startTime = Date.now();
@@ -116228,62 +116547,229 @@ class DevModeOrchestrator {
       await this.componentRegistry.loadAllBlocks();
       await this.blockRegistry.loadBuiltBlocks();
       this.ui.showInitialBuildComplete(blocks.length, blocks.length, 0, Date.now() - startTime);
+    } else {
+      console.log(`\uD83D\uDCE6 Blocks to build: ${blocksToRebuild.map((b) => b.name).join(", ")}`);
+      let successCount = 0;
+      let failCount = 0;
+      const blockScripts = new Map;
+      const results = await this.workerPool.buildAll(blocksToRebuild, (completed, total, blockName, success) => {
+        if (success) {
+          console.log(`   ✅ ${blockName} [${completed}/${total}]`);
+          successCount++;
+        } else {
+          console.log(`   ❌ ${blockName} failed [${completed}/${total}]`);
+          failCount++;
+        }
+      });
+      for (const result2 of results) {
+        if (result2.success) {
+          const block = blocksToRebuild.find((b) => b.name === result2.blockName);
+          if (block) {
+            const hash = this.hashManager.calculateSourceHash(block.filePath);
+            this.hashManager.storeHash(block.name, hash);
+            if (block.scripts && block.scripts.length > 0) {
+              const scriptPaths = block.scripts.map((script) => `scripts/${path17.basename(script).replace(/\.ts$/, ".js")}`);
+              blockScripts.set(block.name, scriptPaths);
+            }
+          }
+        }
+      }
+      if (blockScripts.size > 0) {
+        const phpPath = path17.join(path17.dirname(this.outputDir), "functions-blocks-scripts.php");
+        this.phpGenerator.generateScriptRegistrationPHP(blockScripts, phpPath);
+      }
+      await this.generateTypeDefinitions();
+      await this.componentRegistry.loadAllBlocks();
+      await this.blockRegistry.loadBuiltBlocks();
+      this.ui.showInitialBuildComplete(blocks.length, successCount + cachedCount, failCount, Date.now() - startTime);
+    }
+    if (this.options.buildTemplates && this.templatesDir && this.templatesOutputDir) {
+      await this.performInitialTemplateBuild();
+    }
+    if (this.options.buildTemplates && this.templatePartsDir && this.templatePartsOutputDir) {
+      await this.performInitialTemplatePartsBuild();
+    }
+    if (this.options.autoPush && this.pushCommand) {
+      await this.performInitialContentPush();
+    }
+  }
+  async performInitialContentPush() {
+    if (!fs15.existsSync(this.contentDir))
+      return;
+    const postDir = path17.join(this.contentDir, "post");
+    const pageDir = path17.join(this.contentDir, "page");
+    const contentFiles = [];
+    if (fs15.existsSync(postDir)) {
+      contentFiles.push(...this.findMDXFiles(postDir));
+    }
+    if (fs15.existsSync(pageDir)) {
+      contentFiles.push(...this.findMDXFiles(pageDir));
+    }
+    if (contentFiles.length === 0) {
       return;
     }
-    console.log(`\uD83D\uDCE6 Blocks to build: ${blocksToRebuild.map((b) => b.name).join(", ")}`);
+    console.log(`
+\uD83D\uDE80 Pushing ${contentFiles.length} content file(s)...`);
     let successCount = 0;
     let failCount = 0;
-    const blockScripts = new Map;
-    const results = await this.workerPool.buildAll(blocksToRebuild, (completed, total, blockName, success) => {
-      if (success) {
-        console.log(`   ✅ ${blockName} [${completed}/${total}]`);
+    for (const filePath2 of contentFiles) {
+      const fileName = path17.basename(filePath2);
+      this.ignoreFileTemporarily(filePath2);
+      try {
+        await this.pushPages([filePath2]);
         successCount++;
-      } else {
-        console.log(`   ❌ ${blockName} failed [${completed}/${total}]`);
+      } catch (error) {
+        console.log(`   ❌ ${fileName}: ${error.message}`);
+        failCount++;
+      }
+    }
+    if (failCount === 0) {
+      console.log(`✅ Pushed ${successCount} content file(s)
+`);
+    } else {
+      console.log(`⚠️  Pushed ${successCount} content file(s), ${failCount} failed
+`);
+    }
+  }
+  async performInitialTemplateBuild() {
+    if (!this.templatesDir || !this.templatesOutputDir)
+      return;
+    if (!fs15.existsSync(this.templatesDir))
+      return;
+    const templateFiles = this.findMDXFiles(this.templatesDir);
+    if (templateFiles.length === 0) {
+      logger.info("No templates found to build");
+      return;
+    }
+    console.log(`
+\uD83D\uDCC4 Building ${templateFiles.length} template(s)...`);
+    if (!fs15.existsSync(this.templatesOutputDir)) {
+      fs15.mkdirSync(this.templatesOutputDir, { recursive: true });
+    }
+    const renderer = new OfficialMDXRenderer({
+      blockRegistry: this.blockRegistry
+    });
+    renderer.initialize();
+    let successCount = 0;
+    let failCount = 0;
+    for (const templatePath of templateFiles) {
+      const templateName = path17.basename(templatePath, ".mdx");
+      const relativePath = path17.relative(this.templatesDir, templatePath);
+      try {
+        const mdxContent = fs15.readFileSync(templatePath, "utf8");
+        const cleanContent = this.removeFrontmatter(mdxContent);
+        const html5 = await renderer.renderMDXToHTML(cleanContent);
+        const cleanHTML = renderer.postProcessHTML(html5);
+        const outputPath = path17.join(this.templatesOutputDir, `${templateName}.html`);
+        fs15.writeFileSync(outputPath, cleanHTML, "utf8");
+        console.log(`   ✅ ${relativePath}`);
+        successCount++;
+      } catch (error) {
+        console.log(`   ❌ ${relativePath}: ${error.message}`);
         failCount++;
       }
+    }
+    if (failCount === 0) {
+      console.log(`✅ Built ${successCount} template(s)`);
+    } else {
+      console.log(`⚠️  Built ${successCount} template(s), ${failCount} failed`);
+    }
+  }
+  async performInitialTemplatePartsBuild() {
+    if (!this.templatePartsDir || !this.templatePartsOutputDir)
+      return;
+    if (!fs15.existsSync(this.templatePartsDir))
+      return;
+    const partFiles = this.findMDXFiles(this.templatePartsDir);
+    if (partFiles.length === 0) {
+      logger.info("No template-parts found to build");
+      return;
+    }
+    console.log(`
+\uD83E\uDDE9 Building ${partFiles.length} template-part(s)...`);
+    if (!fs15.existsSync(this.templatePartsOutputDir)) {
+      fs15.mkdirSync(this.templatePartsOutputDir, { recursive: true });
+    }
+    const renderer = new OfficialMDXRenderer({
+      blockRegistry: this.blockRegistry
     });
-    for (const result2 of results) {
-      if (result2.success) {
-        const block = blocksToRebuild.find((b) => b.name === result2.blockName);
-        if (block) {
-          const hash = this.hashManager.calculateSourceHash(block.filePath);
-          this.hashManager.storeHash(block.name, hash);
-          if (block.scripts && block.scripts.length > 0) {
-            const scriptPaths = block.scripts.map((script) => `scripts/${path16.basename(script).replace(/\.ts$/, ".js")}`);
-            blockScripts.set(block.name, scriptPaths);
-          }
-        }
+    renderer.initialize();
+    let successCount = 0;
+    let failCount = 0;
+    for (const partPath of partFiles) {
+      const partName = path17.basename(partPath, ".mdx");
+      const relativePath = path17.relative(this.templatePartsDir, partPath);
+      try {
+        const mdxContent = fs15.readFileSync(partPath, "utf8");
+        const cleanContent = this.removeFrontmatter(mdxContent);
+        const html5 = await renderer.renderMDXToHTML(cleanContent);
+        const cleanHTML = renderer.postProcessHTML(html5);
+        const outputPath = path17.join(this.templatePartsOutputDir, `${partName}.html`);
+        fs15.writeFileSync(outputPath, cleanHTML, "utf8");
+        console.log(`   ✅ ${relativePath}`);
+        successCount++;
+      } catch (error) {
+        console.log(`   ❌ ${relativePath}: ${error.message}`);
+        failCount++;
       }
     }
-    if (blockScripts.size > 0) {
-      const phpPath = path16.join(path16.dirname(this.outputDir), "functions-blocks-scripts.php");
-      this.phpGenerator.generateScriptRegistrationPHP(blockScripts, phpPath);
+    if (failCount === 0) {
+      console.log(`✅ Built ${successCount} template-part(s)`);
+    } else {
+      console.log(`⚠️  Built ${successCount} template-part(s), ${failCount} failed`);
     }
-    await this.generateTypeDefinitions();
-    await this.componentRegistry.loadAllBlocks();
-    await this.blockRegistry.loadBuiltBlocks();
-    this.ui.showInitialBuildComplete(blocks.length, successCount + cachedCount, failCount, Date.now() - startTime);
+  }
+  findMDXFiles(dir) {
+    const files = [];
+    const entries = fs15.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path17.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...this.findMDXFiles(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith(".mdx")) {
+        files.push(fullPath);
+      }
+    }
+    return files;
   }
   startWatchers() {
     this.startBlockWatcher();
     if (this.templatesDir && this.options.buildTemplates) {
       this.startTemplateWatcher();
     }
+    if (this.templatePartsDir && this.options.buildTemplates) {
+      this.startTemplatePartWatcher();
+    }
     if (this.options.autoPush) {
       this.startPageWatcher();
     }
   }
-  startBlockWatcher() {
-    logger.debug(`Watching blocks: ${this.blocksDir}`);
-    const watcher = $watch("**/*.{tsx,ts,jsx,js}", {
-      cwd: this.blocksDir,
+  getWatcherOptions() {
+    const isLinux = process.platform === "linux";
+    return {
       persistent: true,
       ignoreInitial: true,
+      ignored: [
+        "**/node_modules/**",
+        "**/.git/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/*.map"
+      ],
+      usePolling: isLinux,
+      interval: isLinux ? 300 : undefined,
+      binaryInterval: isLinux ? 300 : undefined,
       awaitWriteFinish: {
         stabilityThreshold: 200,
-        pollInterval: 50
+        pollInterval: 100
       }
+    };
+  }
+  startBlockWatcher() {
+    logger.debug(`Watching blocks: ${this.blocksDir}`);
+    const watcher = $watch("**/*.{tsx,ts,jsx,js}", {
+      cwd: this.blocksDir,
+      ...this.getWatcherOptions()
     });
     this.watchers.push(watcher);
     watcher.on("add", (filePath2) => this.handleBlockFileEvent("add", filePath2)).on("change", (filePath2) => this.handleBlockFileEvent("change", filePath2)).on("unlink", (filePath2) => this.handleBlockFileEvent("unlink", filePath2)).on("error", (error) => logger.error("Block watcher error:", error));
@@ -116292,40 +116778,41 @@ class DevModeOrchestrator {
     });
   }
   startTemplateWatcher() {
-    if (!this.templatesDir || !fs14.existsSync(this.templatesDir))
+    if (!this.templatesDir || !fs15.existsSync(this.templatesDir))
       return;
     logger.debug(`Watching templates: ${this.templatesDir}`);
     const watcher = $watch("**/*.mdx", {
       cwd: this.templatesDir,
-      persistent: true,
-      ignoreInitial: true,
-      awaitWriteFinish: {
-        stabilityThreshold: 200,
-        pollInterval: 50
-      }
+      ...this.getWatcherOptions()
     });
     this.watchers.push(watcher);
     watcher.on("add", (filePath2) => this.handleTemplateFileEvent("add", filePath2)).on("change", (filePath2) => this.handleTemplateFileEvent("change", filePath2)).on("unlink", (filePath2) => this.handleTemplateFileEvent("unlink", filePath2)).on("error", (error) => logger.error("Template watcher error:", error));
   }
+  startTemplatePartWatcher() {
+    if (!this.templatePartsDir || !fs15.existsSync(this.templatePartsDir))
+      return;
+    logger.debug(`Watching template-parts: ${this.templatePartsDir}`);
+    const watcher = $watch("**/*.mdx", {
+      cwd: this.templatePartsDir,
+      ...this.getWatcherOptions()
+    });
+    this.watchers.push(watcher);
+    watcher.on("add", (filePath2) => this.handleTemplatePartFileEvent("add", filePath2)).on("change", (filePath2) => this.handleTemplatePartFileEvent("change", filePath2)).on("unlink", (filePath2) => this.handleTemplatePartFileEvent("unlink", filePath2)).on("error", (error) => logger.error("Template-part watcher error:", error));
+  }
   startPageWatcher() {
-    if (!fs14.existsSync(this.contentDir))
+    if (!fs15.existsSync(this.contentDir))
       return;
     logger.debug(`Watching pages: ${this.contentDir}`);
     const watcher = $watch(["post/**/*.mdx", "page/**/*.mdx"], {
       cwd: this.contentDir,
-      persistent: true,
-      ignoreInitial: true,
-      awaitWriteFinish: {
-        stabilityThreshold: 200,
-        pollInterval: 50
-      }
+      ...this.getWatcherOptions()
     });
     this.watchers.push(watcher);
     watcher.on("add", (filePath2) => this.handlePageFileEvent("add", filePath2)).on("change", (filePath2) => this.handlePageFileEvent("change", filePath2)).on("unlink", (filePath2) => this.handlePageFileEvent("unlink", filePath2)).on("error", (error) => logger.error("Page watcher error:", error));
   }
   handleBlockFileEvent(eventType, filePath2) {
-    const fullPath = path16.resolve(this.blocksDir, filePath2);
-    const fileName = path16.basename(filePath2, path16.extname(filePath2));
+    const fullPath = path17.resolve(this.blocksDir, filePath2);
+    const fileName = path17.basename(filePath2, path17.extname(filePath2));
     const isMainBlock = this.blockFilePaths.has(fileName);
     const parentBlock = this.importToBlock.get(fullPath);
     if (isMainBlock) {
@@ -116337,7 +116824,7 @@ class DevModeOrchestrator {
     }
   }
   handleTemplateFileEvent(eventType, filePath2) {
-    const fullPath = path16.resolve(this.templatesDir, filePath2);
+    const fullPath = path17.resolve(this.templatesDir, filePath2);
     this.changeQueue.queueTemplateChange(fullPath, eventType);
     if (eventType === "unlink") {
       this.dependencyTracker.removeFile(fullPath);
@@ -116345,8 +116832,17 @@ class DevModeOrchestrator {
       this.dependencyTracker.updateFileDependencies(fullPath, "template");
     }
   }
+  handleTemplatePartFileEvent(eventType, filePath2) {
+    const fullPath = path17.resolve(this.templatePartsDir, filePath2);
+    this.changeQueue.queueTemplatePartChange(fullPath, eventType);
+    if (eventType === "unlink") {
+      this.dependencyTracker.removeFile(fullPath);
+    } else {
+      this.dependencyTracker.updateFileDependencies(fullPath, "templatePart");
+    }
+  }
   handlePageFileEvent(eventType, filePath2) {
-    const fullPath = path16.resolve(this.contentDir, filePath2);
+    const fullPath = path17.resolve(this.contentDir, filePath2);
     if (this.ignoredFiles.has(fullPath)) {
       logger.debug(`Ignoring self-triggered change: ${filePath2}`);
       return;
@@ -116377,15 +116873,39 @@ class DevModeOrchestrator {
       await this.buildBlocks(blockNames);
     }
     const cascade = this.dependencyTracker.getCascade(blockNames);
+    await this.processDependentArtifacts(batch, cascade);
+  }
+  async processDependentArtifacts(batch, cascade) {
     const allTemplates = [
       ...new Set([...batch.templates, ...cascade.templates])
     ];
+    const allTemplateParts = [
+      ...new Set([...batch.templateParts, ...cascade.templateParts])
+    ];
     const allPages = [...new Set([...batch.pages, ...cascade.pages])];
     if (allTemplates.length > 0 && this.options.buildTemplates) {
-      await this.buildTemplates(allTemplates);
+      await this.processArtifacts("template", allTemplates);
+    }
+    if (allTemplateParts.length > 0 && this.options.buildTemplates) {
+      await this.processArtifacts("templatePart", allTemplateParts);
     }
     if (allPages.length > 0 && this.options.autoPush) {
-      await this.pushPages(allPages);
+      await this.processArtifacts("page", allPages);
+    }
+  }
+  async processArtifacts(type, paths) {
+    switch (type) {
+      case "template":
+        await this.buildTemplates(paths);
+        break;
+      case "templatePart":
+        await this.buildTemplateParts(paths);
+        break;
+      case "page":
+        await this.pushPages(paths);
+        break;
+      default:
+        logger.warn(`Unknown artifact type: ${type}`);
     }
   }
   async buildBlocks(blockNames) {
@@ -116443,18 +116963,63 @@ class DevModeOrchestrator {
     });
     renderer.initialize();
     for (const templatePath of templatePaths) {
-      const templateName = path16.basename(templatePath, ".mdx");
+      const templateName = path17.basename(templatePath, ".mdx");
+      const relativePath = this.templatesDir ? path17.relative(this.templatesDir, templatePath) : templateName;
       const taskId = this.taskScheduler.scheduleTemplateBuild(templatePath, []);
+      const startTime = Date.now();
+      try {
+        const mdxContent = fs15.readFileSync(templatePath, "utf8");
+        const cleanContent = this.removeFrontmatter(mdxContent);
+        const html5 = await renderer.renderMDXToHTML(cleanContent);
+        const cleanHTML = renderer.postProcessHTML(html5);
+        const outputPath = path17.join(this.templatesOutputDir, `${templateName}.html`);
+        fs15.writeFileSync(outputPath, cleanHTML, "utf8");
+        const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(`\uD83D\uDCC4 ${relativePath} → ✅ (${duration}s)`);
+        this.taskScheduler.completeTask(taskId, true);
+      } catch (error) {
+        const errorMsg = error.message;
+        if (errorMsg.length > 60) {
+          console.log(`\uD83D\uDCC4 ${relativePath} → ❌`);
+          console.log(`   ${errorMsg}`);
+        } else {
+          console.log(`\uD83D\uDCC4 ${relativePath} → ❌ ${errorMsg}`);
+        }
+        this.taskScheduler.completeTask(taskId, false, null, errorMsg);
+      }
+    }
+  }
+  async buildTemplateParts(partPaths) {
+    if (!this.templatePartsOutputDir)
+      return;
+    const renderer = new OfficialMDXRenderer({
+      blockRegistry: this.blockRegistry
+    });
+    renderer.initialize();
+    for (const partPath of partPaths) {
+      const partName = path17.basename(partPath, ".mdx");
+      const relativePath = this.templatePartsDir ? path17.relative(this.templatePartsDir, partPath) : partName;
+      const taskId = this.taskScheduler.scheduleTemplateBuild(partPath, []);
+      const startTime = Date.now();
       try {
-        const mdxContent = fs14.readFileSync(templatePath, "utf8");
+        const mdxContent = fs15.readFileSync(partPath, "utf8");
         const cleanContent = this.removeFrontmatter(mdxContent);
         const html5 = await renderer.renderMDXToHTML(cleanContent);
         const cleanHTML = renderer.postProcessHTML(html5);
-        const outputPath = path16.join(this.templatesOutputDir, `${templateName}.html`);
-        fs14.writeFileSync(outputPath, cleanHTML, "utf8");
+        const outputPath = path17.join(this.templatePartsOutputDir, `${partName}.html`);
+        fs15.writeFileSync(outputPath, cleanHTML, "utf8");
+        const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(`\uD83E\uDDE9 ${relativePath} → ✅ (${duration}s)`);
         this.taskScheduler.completeTask(taskId, true);
       } catch (error) {
-        this.taskScheduler.completeTask(taskId, false, null, error.message);
+        const errorMsg = error.message;
+        if (errorMsg.length > 60) {
+          console.log(`\uD83E\uDDE9 ${relativePath} → ❌`);
+          console.log(`   ${errorMsg}`);
+        } else {
+          console.log(`\uD83E\uDDE9 ${relativePath} → ❌ ${errorMsg}`);
+        }
+        this.taskScheduler.completeTask(taskId, false, null, errorMsg);
       }
     }
   }
@@ -116463,7 +117028,7 @@ class DevModeOrchestrator {
       return;
     for (const pagePath of pagePaths) {
       const taskId = this.taskScheduler.schedulePagePush(pagePath, []);
-      const fileName = path16.basename(pagePath);
+      const fileName = path17.basename(pagePath);
       const startTime = Date.now();
       this.ignoreFileTemporarily(pagePath);
       try {
@@ -116491,7 +117056,7 @@ class DevModeOrchestrator {
     try {
       const blocks = await this.typeGenerator.extractBlocksFromDist(this.outputDir);
       if (blocks.length > 0) {
-        const typesPath = path16.join(this.outputDir, "blocks.d.ts");
+        const typesPath = path17.join(this.outputDir, "blocks.d.ts");
         await this.typeGenerator.generateDefinitions(blocks, typesPath);
       }
     } catch (error) {
@@ -116516,6 +117081,11 @@ class DevModeOrchestrator {
       try {
         await this.connectionManager.closeConnection();
       } catch {}
+      if (this.dockerEnvManager) {
+        try {
+          await this.dockerEnvManager.stop();
+        } catch {}
+      }
       this.ui.showShutdownComplete();
       process.exit(0);
     };
@@ -116541,7 +117111,8 @@ class DevCommand {
       concurrency: options.concurrency,
       autoPush: options.push !== false,
       buildTemplates: options.templates !== false,
-      verbose: options.verbose ?? false
+      verbose: options.verbose ?? false,
+      skipEnv: options.skipEnv ?? false
     };
     this.orchestrator = new DevModeOrchestrator(devOptions);
     try {
@@ -116559,37 +117130,37 @@ class DevCommand {
 }
 
 // src/commands/build-command.ts
-import * as path21 from "path";
+import * as path22 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/build/block-builder.ts
-import * as fs17 from "fs";
-import * as path19 from "path";
+import * as fs18 from "fs";
+import * as path20 from "path";
 
 // src/build/webpack-runner.ts
-import * as path17 from "path";
-import * as fs15 from "fs";
-import { execSync } from "child_process";
+import * as path18 from "path";
+import * as fs16 from "fs";
+import { execSync as execSync2 } from "child_process";
 var import_chalk3 = __toESM(require_source(), 1);
 
 class WebpackRunner {
   async runBuild(entryPoint, outputDir, webpackConfigPath) {
     logger.debug(`Running webpack build for: ${entryPoint}`);
-    if (!fs15.existsSync(webpackConfigPath)) {
+    if (!fs16.existsSync(webpackConfigPath)) {
       const error = `Webpack config not found: ${webpackConfigPath}`;
       console.error(import_chalk3.default.red(`
 ❌ ${error}
 `));
       throw new Error(error);
     }
-    if (!fs15.existsSync(entryPoint)) {
+    if (!fs16.existsSync(entryPoint)) {
       const error = `Entry point not found: ${entryPoint}`;
       console.error(import_chalk3.default.red(`
 ❌ ${error}
 `));
       throw new Error(error);
     }
-    fs15.mkdirSync(outputDir, { recursive: true });
+    fs16.mkdirSync(outputDir, { recursive: true });
     const webpackBinary = this.findWebpackBinary();
     logger.debug(`Using webpack binary: ${webpackBinary}`);
     const envVars = {
@@ -116600,9 +117171,9 @@ class WebpackRunner {
     const command = `${webpackBinary} --config "${webpackConfigPath}" ${envString} --mode production`;
     logger.debug(`Full command: ${command}`);
     try {
-      const workingDir = path17.dirname(webpackConfigPath);
+      const workingDir = path18.dirname(webpackConfigPath);
       logger.debug(`Running webpack from directory: ${workingDir}`);
-      const output2 = execSync(command, {
+      const output2 = execSync2(command, {
         cwd: workingDir,
         encoding: "utf8",
         stdio: "pipe"
@@ -116619,7 +117190,7 @@ class WebpackRunner {
       console.error(import_chalk3.default.gray(command));
       console.error("");
       console.error(import_chalk3.default.yellow("Working directory:"));
-      console.error(import_chalk3.default.gray(path17.dirname(webpackConfigPath)));
+      console.error(import_chalk3.default.gray(path18.dirname(webpackConfigPath)));
       console.error("");
       if (error.stdout && error.stdout.trim()) {
         console.error(import_chalk3.default.yellow("Standard output:"));
@@ -116643,13 +117214,13 @@ class WebpackRunner {
   }
   findWebpackBinary() {
     const possiblePaths = [
-      path17.join(process.cwd(), "packages", "block", "node_modules", ".bin", "webpack"),
-      path17.join(process.cwd(), "node_modules", ".bin", "webpack"),
-      path17.join(import.meta.dirname, "..", "..", "..", "node_modules", ".bin", "webpack"),
-      path17.join(process.cwd(), "..", "node_modules", ".bin", "webpack")
+      path18.join(process.cwd(), "packages", "block", "node_modules", ".bin", "webpack"),
+      path18.join(process.cwd(), "node_modules", ".bin", "webpack"),
+      path18.join(import.meta.dirname, "..", "..", "..", "node_modules", ".bin", "webpack"),
+      path18.join(process.cwd(), "..", "node_modules", ".bin", "webpack")
     ];
     for (const webpackPath of possiblePaths) {
-      if (fs15.existsSync(webpackPath)) {
+      if (fs16.existsSync(webpackPath)) {
         logger.debug(`Found webpack at: ${webpackPath}`);
         return webpackPath;
       }
@@ -116660,15 +117231,15 @@ class WebpackRunner {
 }
 
 // src/build/script-builder.ts
-import * as fs16 from "fs";
-import * as path18 from "path";
+import * as fs17 from "fs";
+import * as path19 from "path";
 import * as esbuild from "esbuild";
 class ScriptBuilder {
   async buildScript(scriptPath, outputDir, scriptName) {
     try {
       logger.debug(`Building script: ${scriptName}`);
-      fs16.mkdirSync(outputDir, { recursive: true });
-      const outputPath = path18.join(outputDir, scriptName.replace(/\.ts$/, ".js"));
+      fs17.mkdirSync(outputDir, { recursive: true });
+      const outputPath = path19.join(outputDir, scriptName.replace(/\.ts$/, ".js"));
       await esbuild.build({
         entryPoints: [scriptPath],
         outfile: outputPath,
@@ -116698,19 +117269,19 @@ class ScriptBuilder {
   async buildScripts(scripts, scriptsPath, outputDir) {
     const outputPaths = [];
     for (const script of scripts) {
-      const scriptPath = path18.resolve(scriptsPath, script);
-      if (!fs16.existsSync(scriptPath)) {
+      const scriptPath = path19.resolve(scriptsPath, script);
+      if (!fs17.existsSync(scriptPath)) {
         logger.warn(`Script not found: ${scriptPath}`);
         continue;
       }
-      const scriptName = path18.basename(script);
+      const scriptName = path19.basename(script);
       const outputPath = await this.buildScript(scriptPath, outputDir, scriptName);
       outputPaths.push(outputPath);
     }
     return outputPaths;
   }
   getRelativeScriptPath(blockDistPath, scriptPath) {
-    const relativePath = path18.relative(blockDistPath, scriptPath);
+    const relativePath = path19.relative(blockDistPath, scriptPath);
     return relativePath.replace(/\\/g, "/");
   }
 }
@@ -116724,17 +117295,17 @@ class BlockBuilder {
   constructor() {
     this.webpackRunner = new WebpackRunner;
     this.scriptBuilder = new ScriptBuilder;
-    this.tempDir = path19.join(process.cwd(), ".wordpress-flow-temp");
+    this.tempDir = path20.join(process.cwd(), ".wordpress-flow-temp");
   }
   async buildBlock(block, outputDir, webpackConfigPath, scriptsPath) {
     logger.debug(`Building block: ${block.name}`);
-    fs17.mkdirSync(this.tempDir, { recursive: true });
+    fs18.mkdirSync(this.tempDir, { recursive: true });
     try {
       logger.debug(`[1/6] Generating entry point...`);
       const entryPoint = await this.generateEntryPoint(block);
       logger.debug(`[2/6] Creating output directory...`);
-      const blockOutputDir = path19.join(outputDir, block.name);
-      fs17.mkdirSync(blockOutputDir, { recursive: true });
+      const blockOutputDir = path20.join(outputDir, block.name);
+      fs18.mkdirSync(blockOutputDir, { recursive: true });
       let scriptPaths = [];
       if (block.scripts && block.scripts.length > 0 && scriptsPath) {
         logger.debug(`[3/6] Building ${block.scripts.length} script(s)...`);
@@ -116761,7 +117332,7 @@ class BlockBuilder {
     }
   }
   async buildBlockScripts(scripts, scriptsPath, outputDir) {
-    const scriptsOutputDir = path19.join(path19.dirname(outputDir), "scripts");
+    const scriptsOutputDir = path20.join(path20.dirname(outputDir), "scripts");
     return await this.scriptBuilder.buildScripts(scripts, scriptsPath, scriptsOutputDir);
   }
   async generateEntryPoint(block) {
@@ -116785,14 +117356,14 @@ if (document.readyState === 'loading') {
   blockInstance.register();
 }
 `;
-    const entryPath = path19.join(this.tempDir, `${block.name}-entry.js`);
-    fs17.writeFileSync(entryPath, entryContent, "utf8");
+    const entryPath = path20.join(this.tempDir, `${block.name}-entry.js`);
+    fs18.writeFileSync(entryPath, entryContent, "utf8");
     return entryPath;
   }
   async generateSSRVersion(block, outputDir) {
     try {
       logger.debug(`Generating SSR version for ${block.name} using esbuild`);
-      const ssrPath = path19.join(outputDir, "ssr.js");
+      const ssrPath = path20.join(outputDir, "ssr.js");
       await esbuild2.build({
         entryPoints: [block.filePath],
         outfile: ssrPath,
@@ -116832,8 +117403,8 @@ 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 = path19.join(outputDir, "block.json");
-      fs17.writeFileSync(blockJsonPath, JSON.stringify(blockJson, null, 2), "utf8");
+      const blockJsonPath = path20.join(outputDir, "block.json");
+      fs18.writeFileSync(blockJsonPath, JSON.stringify(blockJson, null, 2), "utf8");
       logger.debug(`Generated block.json for ${block.name}`);
     } catch (error) {
       logger.error(`Failed to generate block.json for ${block.name}:`, error);
@@ -116856,8 +117427,8 @@ if (document.readyState === 'loading') {
         editorStyle: "file:./index.css",
         style: "file:./style-index.css"
       };
-      const blockJsonPath = path19.join(outputDir, "block.json");
-      fs17.writeFileSync(blockJsonPath, JSON.stringify(fallbackBlockJson, null, 2), "utf8");
+      const blockJsonPath = path20.join(outputDir, "block.json");
+      fs18.writeFileSync(blockJsonPath, JSON.stringify(fallbackBlockJson, null, 2), "utf8");
       logger.warn(`Used fallback block.json for ${block.name}`);
     }
   }
@@ -116869,7 +117440,7 @@ if (document.readyState === 'loading') {
   }
   async compileAndImport(filePath2) {
     try {
-      const tempFile = path19.join(this.tempDir, `${path19.basename(filePath2, path19.extname(filePath2))}-compiled.js`);
+      const tempFile = path20.join(this.tempDir, `${path20.basename(filePath2, path20.extname(filePath2))}-compiled.js`);
       logger.debug(`Compiling ${filePath2} to ${tempFile}`);
       if (typeof global.React === "undefined") {
         global.React = require_react();
@@ -116898,8 +117469,8 @@ if (document.readyState === 'loading') {
     }
   }
   parseBlockFromSource(filePath2) {
-    const content4 = fs17.readFileSync(filePath2, "utf8");
-    const blockName = path19.basename(filePath2, ".tsx");
+    const content4 = fs18.readFileSync(filePath2, "utf8");
+    const blockName = path20.basename(filePath2, ".tsx");
     const blockData = this.extractBlockDataFromSource(content4, filePath2);
     return {
       toBlockJson: () => {
@@ -117009,22 +117580,22 @@ 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 = path19.join(outputDir, file);
-      if (!fs17.existsSync(filePath2)) {
+      const filePath2 = path20.join(outputDir, file);
+      if (!fs18.existsSync(filePath2)) {
         throw new Error(`Required build output file missing: ${file}`);
       }
     }
     for (const file of optionalFiles) {
-      const filePath2 = path19.join(outputDir, file);
-      if (fs17.existsSync(filePath2)) {
+      const filePath2 = path20.join(outputDir, file);
+      if (fs18.existsSync(filePath2)) {
         logger.debug(`Generated optional file: ${file}`);
       }
     }
   }
   cleanupTempFiles() {
     try {
-      if (fs17.existsSync(this.tempDir)) {
-        fs17.rmSync(this.tempDir, { recursive: true, force: true });
+      if (fs18.existsSync(this.tempDir)) {
+        fs18.rmSync(this.tempDir, { recursive: true, force: true });
       }
     } catch (error) {
       logger.warn("Failed to clean up temp files:", error);
@@ -117034,7 +117605,7 @@ if (document.readyState === 'loading') {
 
 // src/build/worker-pool.ts
 import { Worker as Worker2 } from "worker_threads";
-import * as path20 from "path";
+import * as path21 from "path";
 import * as os2 from "os";
 class WorkerPool {
   concurrency;
@@ -117047,7 +117618,7 @@ class WorkerPool {
     this.outputDir = options.outputDir;
     this.webpackConfigPath = options.webpackConfigPath;
     this.scriptsPath = options.scriptsPath;
-    this.workerPath = path20.join(import.meta.dirname, "build", "block-build-worker.js");
+    this.workerPath = path21.join(import.meta.dirname, "build", "block-build-worker.js");
   }
   async buildAll(blocks, onProgress) {
     const results = [];
@@ -117056,7 +117627,7 @@ class WorkerPool {
     const total = blocks.length;
     let activeWorkers = 0;
     logger.info(`Building ${total} block(s) with ${this.concurrency} worker(s)`);
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       const processNext = () => {
         while (activeWorkers < this.concurrency && queue.length > 0) {
           const block = queue.shift();
@@ -117069,7 +117640,7 @@ class WorkerPool {
             if (queue.length > 0) {
               processNext();
             } else if (activeWorkers === 0) {
-              resolve7(results);
+              resolve8(results);
             }
           }).catch((error) => {
             const result2 = {
@@ -117084,7 +117655,7 @@ class WorkerPool {
             if (queue.length > 0) {
               processNext();
             } else if (activeWorkers === 0) {
-              resolve7(results);
+              resolve8(results);
             }
           });
         }
@@ -117093,8 +117664,8 @@ class WorkerPool {
     });
   }
   buildBlockInWorker(block) {
-    return new Promise((resolve7, reject) => {
-      const tempDir = path20.join(process.cwd(), ".wordpress-flow-temp", `worker-${block.name}-${Date.now()}`);
+    return new Promise((resolve8, reject) => {
+      const tempDir = path21.join(process.cwd(), ".wordpress-flow-temp", `worker-${block.name}-${Date.now()}`);
       const workerData = {
         block: {
           name: block.name,
@@ -117114,7 +117685,7 @@ class WorkerPool {
       worker.on("message", (result2) => {
         clearTimeout(timeout);
         worker.terminate();
-        resolve7(result2);
+        resolve8(result2);
       });
       worker.on("error", (error) => {
         clearTimeout(timeout);
@@ -117133,7 +117704,7 @@ class WorkerPool {
 
 // src/commands/build-command.ts
 var __filename3 = fileURLToPath5(import.meta.url);
-var __dirname3 = path21.dirname(__filename3);
+var __dirname3 = path22.dirname(__filename3);
 
 class BuildCommand {
   configManager;
@@ -117153,18 +117724,16 @@ class BuildCommand {
   async execute(options) {
     logger.progress("Starting build operation...");
     try {
-      const config2 = this.configManager.getConfig();
-      const blocksDir = this.configManager.resolvePath(options.blocksDir || config2.build?.blocksDir || "./theme/blocks");
-      const outputDir = this.configManager.resolvePath(options.outputDir || config2.build?.outputDir || "./theme/dist");
+      const config = this.configManager.getConfig();
+      const blocksDir = this.configManager.resolvePath(options.blocksDir || config.paths.blocks);
+      const outputDir = this.configManager.resolvePath(options.outputDir || config.paths.dist);
       let webpackConfig;
       if (options.webpackConfig) {
         webpackConfig = this.configManager.resolvePath(options.webpackConfig);
-      } else if (config2.build?.webpackConfig) {
-        webpackConfig = this.configManager.resolvePath(config2.build.webpackConfig);
       } else {
-        webpackConfig = path21.join(__dirname3, "..", "webpack.config.cjs");
+        webpackConfig = path22.join(__dirname3, "..", "webpack.config.cjs");
       }
-      const scriptsPath = config2.build?.scriptsPath ? this.configManager.resolvePath(config2.build.scriptsPath) : undefined;
+      const scriptsPath = this.configManager.resolvePath(config.paths.scripts);
       logger.info(`Scanning blocks in: ${blocksDir}`);
       logger.info(`Output directory: ${outputDir}`);
       if (scriptsPath) {
@@ -117211,7 +117780,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/${path21.basename(script).replace(/\.ts$/, ".js")}`);
+            const scriptPaths = block.scripts.map((script) => `dist/scripts/${path22.basename(script).replace(/\.ts$/, ".js")}`);
             this.blockScripts.set(block.name, scriptPaths);
           }
         }
@@ -117225,7 +117794,7 @@ Failed to build ${failures.length} block(s):`);
         }
       }
       if (this.blockScripts.size > 0) {
-        const phpPath = path21.join(path21.dirname(outputDir), "functions-blocks-scripts.php");
+        const phpPath = path22.join(path22.dirname(outputDir), "functions-blocks-scripts.php");
         this.phpGenerator.generateScriptRegistrationPHP(this.blockScripts, phpPath);
       }
       await this.generateTypeDefinitions(outputDir);
@@ -117253,7 +117822,7 @@ Failed to build ${failures.length} block(s):`);
         logger.warn("No blocks found for type generation");
         return;
       }
-      const typesPath = path21.join(outputDir, "blocks.d.ts");
+      const typesPath = path22.join(outputDir, "blocks.d.ts");
       await this.typeGenerator.generateDefinitions(blocks, typesPath);
       logger.success(`✅ Generated TypeScript definitions for ${blocks.length} block(s)`);
     } catch (error) {
@@ -117263,8 +117832,8 @@ Failed to build ${failures.length} block(s):`);
 }
 
 // src/commands/build-templates-command.ts
-import * as fs18 from "fs";
-import * as path22 from "path";
+import * as fs19 from "fs";
+import * as path23 from "path";
 class BuildTemplatesCommand {
   configManager;
   constructor() {
@@ -117272,28 +117841,18 @@ class BuildTemplatesCommand {
   }
   async execute(options = {}) {
     logger.progress("Starting template build operation...");
-    const config2 = this.configManager.getConfig();
-    const templatesConfig = config2.templates;
-    if (!templatesConfig) {
-      logger.error("Templates configuration not found in wordpress-flow.config.json");
-      logger.info('Add a "templates" section to your config with "templatesDir" and "outputDir"');
-      return;
-    }
-    const templatesDir = options.templatesDir || this.configManager.resolvePath(templatesConfig.templatesDir);
-    const outputDir = options.outputDir || this.configManager.resolvePath(templatesConfig.outputDir);
-    if (!fs18.existsSync(templatesDir)) {
+    const config = this.configManager.getConfig();
+    const templatesDir = options.templatesDir || this.configManager.resolvePath(config.paths.templates);
+    const outputDir = options.outputDir || this.configManager.resolvePath(config.paths.templatesOutput);
+    if (!fs19.existsSync(templatesDir)) {
       logger.error(`Templates directory not found: ${templatesDir}`);
       return;
     }
-    fs18.mkdirSync(outputDir, { recursive: true });
-    const buildConfig = config2.build;
-    let blockRegistry;
-    if (buildConfig) {
-      const blocksOutputDir = this.configManager.resolvePath(buildConfig.outputDir);
-      blockRegistry = new BlockRegistry(blocksOutputDir);
-      await blockRegistry.loadBuiltBlocks();
-      logger.info(`Loaded ${blockRegistry.getAllComponentMappings().length} built blocks`);
-    }
+    fs19.mkdirSync(outputDir, { recursive: true });
+    const blocksOutputDir = this.configManager.resolvePath(config.paths.dist);
+    const blockRegistry = new BlockRegistry(blocksOutputDir);
+    await blockRegistry.loadBuiltBlocks();
+    logger.info(`Loaded ${blockRegistry.getAllComponentMappings().length} built blocks`);
     const renderer = new OfficialMDXRenderer({ blockRegistry });
     renderer.initialize();
     const templateFiles = this.findMDXFiles(templatesDir);
@@ -117306,8 +117865,8 @@ class BuildTemplatesCommand {
     let errorCount = 0;
     for (let i2 = 0;i2 < templateFiles.length; i2++) {
       const templateFile = templateFiles[i2];
-      const relativePath = path22.relative(templatesDir, templateFile);
-      const templateName = path22.basename(templateFile, ".mdx");
+      const relativePath = path23.relative(templatesDir, templateFile);
+      const templateName = path23.basename(templateFile, ".mdx");
       logger.step(i2 + 1, templateFiles.length, `Building template: ${relativePath}`);
       try {
         await this.buildTemplate(templateFile, templateName, outputDir, renderer);
@@ -117327,19 +117886,19 @@ class BuildTemplatesCommand {
     }
   }
   async buildTemplate(templatePath, templateName, outputDir, renderer) {
-    const mdxContent = fs18.readFileSync(templatePath, "utf8");
+    const mdxContent = fs19.readFileSync(templatePath, "utf8");
     const cleanContent = this.removeFrontmatter(mdxContent);
     const html5 = await renderer.renderMDXToHTML(cleanContent);
     const cleanHTML = renderer.postProcessHTML(html5);
-    const outputPath = path22.join(outputDir, `${templateName}.html`);
-    fs18.writeFileSync(outputPath, cleanHTML, "utf8");
-    logger.info(`✓ Generated: ${path22.relative(process.cwd(), outputPath)}`);
+    const outputPath = path23.join(outputDir, `${templateName}.html`);
+    fs19.writeFileSync(outputPath, cleanHTML, "utf8");
+    logger.info(`✓ Generated: ${path23.relative(process.cwd(), outputPath)}`);
   }
   findMDXFiles(dir) {
     const files = [];
-    const entries = fs18.readdirSync(dir, { withFileTypes: true });
+    const entries = fs19.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path22.join(dir, entry.name);
+      const fullPath = path23.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...this.findMDXFiles(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".mdx")) {
@@ -117354,6 +117913,69 @@ class BuildTemplatesCommand {
   }
 }
 
+// src/commands/env-command.ts
+import * as fs20 from "fs";
+import * as path24 from "path";
+class EnvCommand {
+  configManager;
+  constructor() {
+    this.configManager = ConfigManager.getInstance();
+  }
+  getDockerEnvManager() {
+    const config = this.configManager.getConfig();
+    const packageJsonPath = path24.join(this.configManager.getConfigDir(), "package.json");
+    let projectName = "wordpress-project";
+    if (fs20.existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs20.readFileSync(packageJsonPath, "utf8"));
+        projectName = pkg.name || projectName;
+      } catch {}
+    }
+    return new DockerEnvManager({
+      projectName,
+      workspaceDir: this.configManager.getConfigDir(),
+      config
+    });
+  }
+  async destroy() {
+    console.log(`
+\uD83D\uDDD1️  Destroying Docker environment...
+`);
+    const manager = this.getDockerEnvManager();
+    await manager.cleanup();
+    console.log(`
+✅ Docker environment destroyed
+`);
+  }
+  async dbImport(filePath2) {
+    const config = this.configManager.getConfig();
+    const inputPath = filePath2 || config.dev.sqlDump;
+    if (!inputPath) {
+      throw new Error("No SQL file specified. Use --file option or set 'sqlDump' in config.");
+    }
+    console.log(`
+\uD83D\uDCE5 Importing database from ${inputPath}...
+`);
+    const manager = this.getDockerEnvManager();
+    await manager.importSqlDumpFromFile(inputPath);
+    console.log(`
+✅ Database imported successfully
+`);
+  }
+  async dbExport(filePath2) {
+    const config = this.configManager.getConfig();
+    const outputPath = filePath2 || config.dev.sqlDump || "./db/dump.sql";
+    console.log(`
+\uD83D\uDCE4 Exporting database to ${outputPath}...
+`);
+    const manager = this.getDockerEnvManager();
+    await manager.exportSqlDump(outputPath);
+    console.log(`
+✅ Database exported successfully
+`);
+  }
+}
+
 // src/index.ts
 var program2 = new Command;
 program2.name("wordpress-flow").description("Build WordPress sites with React, TypeScript, and MDX - A content-first development framework").version(package_default.version);
@@ -117438,7 +118060,7 @@ program2.command("build-templates").description("Build WordPress theme templates
     process.exit(1);
   }
 });
-program2.command("dev").description("Unified development mode - watches blocks, templates, and pages with optimized rebuilds").option("--fresh", "Force full rebuild, ignore cached hashes").option("--debounce <ms>", "Change batching window in milliseconds (default: 300)", "300").option("-c, --concurrency <number>", "Number of parallel workers (default: CPU cores - 1)").option("--no-push", "Disable auto-push to WordPress").option("--no-templates", "Disable template rebuilding").option("-v, --verbose", "Enable verbose output").action(async (options) => {
+program2.command("dev").description("Unified development mode - watches blocks, templates, and pages with optimized rebuilds").option("--fresh", "Force full rebuild, ignore cached hashes").option("--debounce <ms>", "Change batching window in milliseconds (default: 300)", "300").option("-c, --concurrency <number>", "Number of parallel workers (default: CPU cores - 1)").option("--no-push", "Disable auto-push to WordPress").option("--no-templates", "Disable template rebuilding").option("--skip-env", "Skip Docker environment setup").option("-v, --verbose", "Enable verbose output").action(async (options) => {
   try {
     await ensureConfiguration();
     const command = new DevCommand;
@@ -117448,6 +118070,7 @@ program2.command("dev").description("Unified development mode - watches blocks,
       concurrency: options.concurrency ? parseInt(options.concurrency, 10) : undefined,
       push: options.push !== false,
       templates: options.templates !== false,
+      skipEnv: options.skipEnv || false,
       verbose: options.verbose || false
     });
   } catch (error) {
@@ -117455,6 +118078,36 @@ program2.command("dev").description("Unified development mode - watches blocks,
     process.exit(1);
   }
 });
+program2.command("destroy").description("Remove Docker containers and volumes for this project").action(async () => {
+  try {
+    await ensureConfiguration();
+    const command = new EnvCommand;
+    await command.destroy();
+  } catch (error) {
+    logger.error("Destroy command failed:", error);
+    process.exit(1);
+  }
+});
+program2.command("database import").description("Import SQL dump into Docker database").option("-f, --file <path>", "Path to SQL file (defaults to config sqlDump)").action(async (options) => {
+  try {
+    await ensureConfiguration();
+    const command = new EnvCommand;
+    await command.dbImport(options.file);
+  } catch (error) {
+    logger.error("Database import failed:", error);
+    process.exit(1);
+  }
+});
+program2.command("database export").description("Export Docker database to SQL file").option("-f, --file <path>", "Output path for SQL file (defaults to config sqlDump or ./db/dump.sql)").action(async (options) => {
+  try {
+    await ensureConfiguration();
+    const command = new EnvCommand;
+    await command.dbExport(options.file);
+  } catch (error) {
+    logger.error("Database export failed:", error);
+    process.exit(1);
+  }
+});
 async function ensureConfiguration() {
   const configManager = ConfigManager.getInstance();
   if (!configManager.hasConfig()) {