@json-to-office/jto 0.1.0

package/dist/index.js

@@ -0,0 +1,2303 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/format-adapter.ts
+import * as path from "path";
+import * as fs from "fs";
+var DocxFormatAdapter = class {
+  name = "docx";
+  extension = ".docx";
+  label = "document";
+  defaultPort = 3003;
+  async generateBuffer(json, options) {
+    const core = await import("@json-to-office/core-docx");
+    const docDefinition = typeof json === "string" ? JSON.parse(json) : json;
+    const customThemes = await this.loadCustomThemes(options);
+    return await core.generateBufferFromJson(docDefinition, { customThemes });
+  }
+  async createGenerator(plugins, options) {
+    const core = await import("@json-to-office/core-docx");
+    const hasPlugins = plugins.length > 0;
+    const pluginNames = plugins.map((p) => p.name);
+    if (!hasPlugins) {
+      return {
+        generateBuffer: async (document) => {
+          const docDefinition = typeof document === "string" ? JSON.parse(document) : document;
+          const customThemes = await this.loadCustomThemes(options);
+          return await core.generateBufferFromJson(docDefinition, { customThemes });
+        },
+        hasPlugins: false,
+        pluginNames: []
+      };
+    }
+    const theme = await this.resolveTheme(options);
+    let generator = core.createDocumentGenerator({
+      theme,
+      debug: process.env.DEBUG === "true"
+    });
+    for (const plugin of plugins) {
+      generator = generator.addComponent(plugin);
+    }
+    return {
+      generateBuffer: async (document) => {
+        const docDefinition = typeof document === "string" ? JSON.parse(document) : document;
+        const validationResult = generator.validate(docDefinition);
+        if (!validationResult.valid) {
+          const errors = validationResult.errors || [];
+          throw new Error(
+            `Document validation failed:
+${errors.map((e) => `  - ${e.path}: ${e.message}`).join("\n")}`
+          );
+        }
+        const result = await generator.generateBuffer(docDefinition);
+        return result.buffer;
+      },
+      getStandardComponentsDefinition: generator.getStandardComponentsDefinition ? (config) => generator.getStandardComponentsDefinition(config) : void 0,
+      hasPlugins: true,
+      pluginNames
+    };
+  }
+  parseJson(input) {
+    return typeof input === "string" ? JSON.parse(input) : input;
+  }
+  validateDocument(_doc) {
+    return { valid: true };
+  }
+  generateSchema(_options) {
+    return null;
+  }
+  getBuiltinThemes() {
+    try {
+      const core = __require("@json-to-office/core-docx");
+      return core.themes || {};
+    } catch {
+      return {};
+    }
+  }
+  async resolveTheme(options) {
+    const core = await import("@json-to-office/core-docx");
+    if (options.themePath) {
+      try {
+        if (options.themePath.endsWith(".json")) {
+          return await core.loadThemeFromFile(options.themePath);
+        } else {
+          const themePath = path.resolve(process.cwd(), options.themePath);
+          const themeModule = await import(themePath);
+          return themeModule.default || themeModule.theme;
+        }
+      } catch (error) {
+        console.warn(
+          `Failed to load theme from ${options.themePath}: ${error.message}`
+        );
+      }
+    }
+    if (typeof options.theme === "string") {
+      const builtInTheme = core.themes?.[options.theme];
+      if (builtInTheme) return builtInTheme;
+      if (options.theme.endsWith(".json") && fs.existsSync(options.theme)) {
+        try {
+          return await core.loadThemeFromFile(options.theme);
+        } catch {
+        }
+      }
+      try {
+        return await core.loadThemeFromJson(options.theme);
+      } catch {
+      }
+    }
+    if (typeof options.theme === "object" && options.theme !== null) {
+      return options.theme;
+    }
+    return core.themes?.minimal || {};
+  }
+  async loadCustomThemes(options) {
+    const core = await import("@json-to-office/core-docx");
+    const customThemes = {};
+    if (options.customThemes) {
+      Object.assign(customThemes, options.customThemes);
+    }
+    if (typeof options.theme === "object" && options.theme !== null) {
+      customThemes.custom = options.theme;
+    }
+    if (options.themePath) {
+      try {
+        if (options.themePath.endsWith(".json")) {
+          customThemes.custom = await core.loadThemeFromFile(options.themePath);
+        } else {
+          const themePath = path.resolve(process.cwd(), options.themePath);
+          const themeModule = await import(themePath);
+          customThemes.custom = themeModule.default || themeModule.theme;
+        }
+      } catch (error) {
+        console.warn(
+          `Failed to load theme from ${options.themePath}: ${error.message}`
+        );
+      }
+    }
+    return Object.keys(customThemes).length > 0 ? customThemes : void 0;
+  }
+  async getComponentCacheStats() {
+    try {
+      const core = await import("@json-to-office/core-docx");
+      const stats = core.getComponentCacheStats?.();
+      if (!stats) return null;
+      const componentStats = Array.from(
+        stats.componentStats.entries()
+      ).map(([, s]) => {
+        const total = s.hits + s.misses;
+        const hitRate = total > 0 ? s.hits / total : 0;
+        return {
+          type: s.name,
+          hits: s.hits,
+          misses: s.misses,
+          avgProcessTime: s.avgProcessTime,
+          avgSize: s.avgSize,
+          entries: s.entries,
+          hitRate,
+          missRate: total > 0 ? s.misses / total : 0,
+          totalRequests: total,
+          memoryUsage: s.entries * s.avgSize,
+          efficiencyScore: Math.round(hitRate * 100)
+        };
+      });
+      return {
+        entries: stats.entries,
+        totalSize: stats.totalSize,
+        hitRate: stats.hitRate,
+        missRate: stats.missRate,
+        totalHits: stats.totalHits,
+        totalMisses: stats.totalMisses,
+        avgResponseTime: stats.avgResponseTime,
+        evictions: stats.evictions,
+        componentStats
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getComponentCacheAnalytics() {
+    try {
+      const core = await import("@json-to-office/core-docx");
+      const stats = core.getComponentCacheStats?.();
+      if (!stats) return null;
+      const analytics = new core.ComponentCacheAnalytics();
+      const report = analytics.analyzeCache(stats);
+      return {
+        ...report,
+        componentMetrics: report.componentMetrics.map((m) => ({
+          componentType: m.componentName,
+          hitRate: m.hitRate,
+          totalRequests: m.totalRequests,
+          avgHitTime: m.avgHitTime,
+          avgMissTime: m.avgMissTime,
+          efficiencyScore: m.efficiencyScore,
+          memoryUsage: m.memoryUsage,
+          timeSaved: m.timeSaved,
+          costBenefitRatio: m.costBenefitRatio
+        })),
+        recommendations: report.recommendations.map((r) => ({
+          componentType: r.componentName,
+          type: r.type,
+          description: r.description,
+          expectedImprovement: r.expectedImprovement,
+          priority: r.priority,
+          reasoning: r.reasoning
+        }))
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+var PptxFormatAdapter = class {
+  name = "pptx";
+  extension = ".pptx";
+  label = "presentation";
+  defaultPort = 3004;
+  async generateBuffer(json, options) {
+    const core = await import("@json-to-office/core-pptx");
+    const docDefinition = typeof json === "string" ? JSON.parse(json) : json;
+    const customThemes = await this.loadCustomThemes(options);
+    return await core.generateBufferFromJson(docDefinition, { customThemes });
+  }
+  async createGenerator(plugins, options) {
+    const core = await import("@json-to-office/core-pptx");
+    const hasPlugins = plugins.length > 0;
+    const pluginNames = plugins.map((p) => p.name);
+    return {
+      generateBuffer: async (document) => {
+        const docDefinition = typeof document === "string" ? JSON.parse(document) : document;
+        const customThemes = await this.loadCustomThemes(options);
+        return await core.generateBufferFromJson(docDefinition, { customThemes });
+      },
+      hasPlugins,
+      pluginNames
+    };
+  }
+  parseJson(input) {
+    return typeof input === "string" ? JSON.parse(input) : input;
+  }
+  validateDocument(_doc) {
+    return { valid: true };
+  }
+  generateSchema(_options) {
+    return null;
+  }
+  getBuiltinThemes() {
+    try {
+      const core = __require("@json-to-office/core-pptx");
+      return core.pptxThemes || {};
+    } catch {
+      return {};
+    }
+  }
+  async resolveTheme(options) {
+    const core = await import("@json-to-office/core-pptx");
+    const themes = core.pptxThemes || {};
+    if (options.themePath) {
+      try {
+        if (options.themePath.endsWith(".json")) {
+          const content = fs.readFileSync(
+            path.resolve(process.cwd(), options.themePath),
+            "utf-8"
+          );
+          return JSON.parse(content);
+        } else {
+          const themePath = path.resolve(process.cwd(), options.themePath);
+          const themeModule = await import(themePath);
+          return themeModule.default || themeModule.theme;
+        }
+      } catch (error) {
+        console.warn(
+          `Failed to load theme from ${options.themePath}: ${error.message}`
+        );
+      }
+    }
+    if (typeof options.theme === "string") {
+      const builtIn = themes[options.theme] || core.getPptxTheme?.(options.theme);
+      if (builtIn) return builtIn;
+      if (options.theme.endsWith(".json") && fs.existsSync(options.theme)) {
+        try {
+          const content = fs.readFileSync(
+            path.resolve(process.cwd(), options.theme),
+            "utf-8"
+          );
+          return JSON.parse(content);
+        } catch {
+        }
+      }
+    }
+    if (typeof options.theme === "object" && options.theme !== null) {
+      return options.theme;
+    }
+    return themes.minimal || {};
+  }
+  async loadCustomThemes(options) {
+    const customThemes = {};
+    if (options.customThemes) {
+      Object.assign(customThemes, options.customThemes);
+    }
+    if (typeof options.theme === "object" && options.theme !== null) {
+      customThemes.custom = options.theme;
+    }
+    if (options.themePath) {
+      try {
+        if (options.themePath.endsWith(".json")) {
+          const content = fs.readFileSync(
+            path.resolve(process.cwd(), options.themePath),
+            "utf-8"
+          );
+          customThemes.custom = JSON.parse(content);
+        } else {
+          const themePath = path.resolve(process.cwd(), options.themePath);
+          const themeModule = await import(themePath);
+          customThemes.custom = themeModule.default || themeModule.theme;
+        }
+      } catch (error) {
+        console.warn(
+          `Failed to load theme from ${options.themePath}: ${error.message}`
+        );
+      }
+    }
+    return Object.keys(customThemes).length > 0 ? customThemes : void 0;
+  }
+};
+function createAdapter(format) {
+  switch (format) {
+    case "docx":
+      return new DocxFormatAdapter();
+    case "pptx":
+      return new PptxFormatAdapter();
+    default:
+      throw new Error(`Unknown format: ${format}`);
+  }
+}
+
+// src/services/plugin-loader.ts
+import * as path2 from "path";
+import { pathToFileURL } from "url";
+var globalTsxUnregister;
+var tsxInitializationPromise;
+var PluginLoader = class {
+  tsxUnregister;
+  async initialize() {
+    if (globalTsxUnregister) {
+      this.tsxUnregister = globalTsxUnregister;
+      return;
+    }
+    if (tsxInitializationPromise) {
+      await tsxInitializationPromise;
+      this.tsxUnregister = globalTsxUnregister;
+      return;
+    }
+    tsxInitializationPromise = (async () => {
+      try {
+        const { register } = await import("tsx/esm/api");
+        globalTsxUnregister = register();
+        this.tsxUnregister = globalTsxUnregister;
+      } catch {
+        console.warn("tsx not available, TypeScript module loading may fail");
+      }
+    })();
+    await tsxInitializationPromise;
+  }
+  async loadPlugin(filePath) {
+    try {
+      if (!filePath.endsWith(".ts")) {
+        return null;
+      }
+      if (!this.tsxUnregister) {
+        await this.initialize();
+      }
+      const fileUrl = pathToFileURL(filePath).href;
+      const module = await import(`${fileUrl}?t=${Date.now()}`);
+      return this.extractComponent(module, filePath);
+    } catch (error) {
+      if (process.env.DEBUG) {
+        console.error(`Failed to load plugin from ${filePath}:`, error);
+      } else {
+        console.warn(
+          `Failed to load plugin from ${path2.basename(filePath)}: ${error.message}`
+        );
+      }
+      return null;
+    }
+  }
+  async loadPlugins(filePaths) {
+    const plugins = /* @__PURE__ */ new Map();
+    const results = await Promise.allSettled(
+      filePaths.map(async (filePath) => {
+        const module = await this.loadPlugin(filePath);
+        return { filePath, module };
+      })
+    );
+    for (const result of results) {
+      if (result.status === "fulfilled" && result.value.module) {
+        plugins.set(result.value.filePath, result.value.module);
+      }
+    }
+    return plugins;
+  }
+  extractComponent(module, filePath) {
+    if (module.default && this.isValidComponent(module.default)) {
+      return module.default;
+    }
+    const componentExports = Object.entries(module).filter(
+      ([key]) => key.endsWith("Component") || key.endsWith("component") || key.endsWith("Module") || key.endsWith("module")
+    ).map(([_, value]) => value);
+    for (const exportedValue of componentExports) {
+      if (this.isValidComponent(exportedValue)) {
+        return exportedValue;
+      }
+    }
+    for (const [key, value] of Object.entries(module)) {
+      if (this.isValidComponent(value)) {
+        if (process.env.DEBUG) {
+          console.log(
+            `Found component in export '${key}' from ${path2.basename(filePath)}`
+          );
+        }
+        return value;
+      }
+    }
+    return null;
+  }
+  isValidComponent(obj) {
+    if (!obj || typeof obj !== "object") {
+      return false;
+    }
+    const hasName = typeof obj.name === "string" && obj.name.length > 0;
+    if (obj.versions && typeof obj.versions === "object") {
+      const entries = Object.values(obj.versions);
+      return hasName && entries.length > 0 && entries.some(
+        (entry) => entry && typeof entry === "object" && entry.propsSchema && typeof entry.propsSchema === "object" && typeof entry.render === "function"
+      );
+    }
+    return false;
+  }
+  cleanup() {
+    this.tsxUnregister = void 0;
+  }
+};
+
+// src/services/plugin-discovery.ts
+import * as path6 from "path";
+import * as fs5 from "fs/promises";
+
+// src/services/file-scanner.ts
+import { glob } from "glob";
+import * as path3 from "path";
+import * as fs2 from "fs/promises";
+var FileSystemScanner = class {
+  FILE_PATTERNS = {
+    plugin: {
+      type: "plugin",
+      pattern: "*.component.ts",
+      monorepoPatterns: [
+        "packages/*/src/**/*.component.ts",
+        "packages/**/src/**/*.component.ts",
+        "apps/*/src/**/*.component.ts",
+        "apps/**/src/**/*.component.ts",
+        "libs/*/src/**/*.component.ts",
+        "libs/**/src/**/*.component.ts",
+        "components/**/*.component.ts",
+        "plugins/**/*.component.ts",
+        "src/plugins/**/*.component.ts",
+        "src/components/**/*.component.ts"
+      ]
+    },
+    "docx-document": {
+      type: "docx-document",
+      pattern: "*.docx.json",
+      monorepoPatterns: [
+        "packages/*/src/**/*.docx.json",
+        "packages/**/src/**/*.docx.json",
+        "apps/*/src/**/*.docx.json",
+        "apps/**/src/**/*.docx.json",
+        "libs/*/src/**/*.docx.json",
+        "libs/**/src/**/*.docx.json",
+        "documents/**/*.docx.json",
+        "src/documents/**/*.docx.json",
+        "templates/**/*.docx.json",
+        "src/templates/**/*.docx.json"
+      ]
+    },
+    "pptx-document": {
+      type: "pptx-document",
+      pattern: "*.pptx.json",
+      monorepoPatterns: [
+        "packages/*/src/**/*.pptx.json",
+        "packages/**/src/**/*.pptx.json",
+        "apps/*/src/**/*.pptx.json",
+        "apps/**/src/**/*.pptx.json",
+        "libs/*/src/**/*.pptx.json",
+        "libs/**/src/**/*.pptx.json",
+        "documents/**/*.pptx.json",
+        "src/documents/**/*.pptx.json",
+        "templates/**/*.pptx.json",
+        "src/templates/**/*.pptx.json"
+      ]
+    },
+    "pptx-theme": {
+      type: "pptx-theme",
+      pattern: "*.pptx.theme.json",
+      monorepoPatterns: [
+        "packages/*/src/**/*.pptx.theme.json",
+        "packages/**/src/**/*.pptx.theme.json",
+        "apps/*/src/**/*.pptx.theme.json",
+        "apps/**/src/**/*.pptx.theme.json",
+        "libs/*/src/**/*.pptx.theme.json",
+        "libs/**/src/**/*.pptx.theme.json",
+        "themes/**/*.pptx.theme.json",
+        "src/themes/**/*.pptx.theme.json",
+        "templates/**/*.pptx.theme.json",
+        "src/templates/**/*.pptx.theme.json"
+      ]
+    },
+    "docx-theme": {
+      type: "docx-theme",
+      pattern: "*.docx.theme.json",
+      monorepoPatterns: [
+        "packages/*/src/**/*.docx.theme.json",
+        "packages/**/src/**/*.docx.theme.json",
+        "apps/*/src/**/*.docx.theme.json",
+        "apps/**/src/**/*.docx.theme.json",
+        "libs/*/src/**/*.docx.theme.json",
+        "libs/**/src/**/*.docx.theme.json",
+        "themes/**/*.docx.theme.json",
+        "src/themes/**/*.docx.theme.json",
+        "templates/**/*.docx.theme.json",
+        "src/templates/**/*.docx.theme.json"
+      ]
+    }
+  };
+  EXCLUDE_PATTERNS = [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.git/**",
+    "**/coverage/**",
+    "**/.next/**",
+    "**/.turbo/**",
+    "**/tmp/**",
+    "**/.cache/**",
+    "**/out/**"
+  ];
+  async scan(basePath, fileType = "plugin", options = {}) {
+    const {
+      maxDepth = 10,
+      excludeNodeModules = true,
+      additionalIgnore = []
+    } = options;
+    const patterns = this.buildPatterns(fileType, maxDepth);
+    const ignore = this.buildIgnorePatterns(
+      excludeNodeModules,
+      additionalIgnore
+    );
+    try {
+      const files = await glob(patterns, {
+        cwd: basePath,
+        absolute: true,
+        ignore,
+        nodir: true
+      });
+      return files;
+    } catch {
+      return [];
+    }
+  }
+  async scanMonorepoLocations(rootPath, fileType = "plugin") {
+    const monorepoPatterns = this.FILE_PATTERNS[fileType].monorepoPatterns || [];
+    const allFiles = [];
+    for (const pattern of monorepoPatterns) {
+      try {
+        const matches = await glob(pattern, {
+          cwd: rootPath,
+          absolute: true,
+          ignore: this.EXCLUDE_PATTERNS
+        });
+        allFiles.push(...matches);
+      } catch {
+      }
+    }
+    return allFiles;
+  }
+  async hasPackageJson(dirPath) {
+    try {
+      await fs2.access(path3.join(dirPath, "package.json"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  isInNodeModules(currentPath) {
+    return currentPath.includes("node_modules");
+  }
+  buildPatterns(fileType, maxDepth) {
+    const filePattern = this.FILE_PATTERNS[fileType].pattern;
+    const patterns = [filePattern];
+    for (let depth = 1; depth <= maxDepth; depth++) {
+      const depthPattern = Array(depth).fill("*").join("/") + "/" + filePattern;
+      patterns.push(depthPattern);
+    }
+    return patterns;
+  }
+  buildIgnorePatterns(excludeNodeModules, additionalIgnore) {
+    let ignore = [...this.EXCLUDE_PATTERNS];
+    if (!excludeNodeModules) {
+      ignore = ignore.filter((pattern) => !pattern.includes("node_modules"));
+    }
+    return [...ignore, ...additionalIgnore];
+  }
+  deduplicatePaths(paths) {
+    const uniquePaths = new Set(paths.map((p) => path3.resolve(p)));
+    return Array.from(uniquePaths);
+  }
+};
+
+// src/services/plugin-metadata.ts
+import * as path4 from "path";
+import * as fs3 from "fs/promises";
+import { latestVersion } from "@json-to-office/shared";
+var PluginMetadataExtractor = class {
+  cwd;
+  constructor(cwd) {
+    this.cwd = cwd || process.cwd();
+  }
+  async extract(component, filePath) {
+    const location = this.determineLocation(filePath);
+    const relativePath = path4.relative(this.cwd, filePath);
+    const versions = component.versions || {};
+    const versionKeys = Object.keys(versions);
+    const latestVer = versionKeys.length > 0 ? latestVersion(versionKeys) : void 0;
+    const latestEntry = latestVer ? versions[latestVer] : void 0;
+    const metadata = {
+      name: component.name,
+      description: latestEntry?.description,
+      version: latestVer,
+      filePath,
+      relativePath,
+      location,
+      hasChildren: latestEntry?.hasChildren === true,
+      schema: {
+        raw: latestEntry?.propsSchema
+      }
+    };
+    if (latestEntry?.propsSchema) {
+      try {
+        metadata.schema.jsonSchema = this.typeboxToJsonSchema(
+          latestEntry.propsSchema
+        );
+        metadata.schema.properties = this.extractProperties(
+          latestEntry.propsSchema
+        );
+      } catch {
+      }
+    }
+    try {
+      metadata.examples = await this.extractExamples(filePath);
+    } catch {
+      metadata.examples = [];
+    }
+    return metadata;
+  }
+  determineLocation(filePath) {
+    const resolvedPath = path4.resolve(filePath);
+    const resolvedCwd = path4.resolve(this.cwd);
+    if (path4.dirname(resolvedPath) === resolvedCwd) {
+      return "current";
+    }
+    if (resolvedPath.startsWith(resolvedCwd)) {
+      return "downstream";
+    }
+    return "upstream";
+  }
+  typeboxToJsonSchema(schema) {
+    try {
+      const jsonSchema = JSON.parse(JSON.stringify(schema));
+      delete jsonSchema[Symbol.for("TypeBox.Kind")];
+      delete jsonSchema.static;
+      return jsonSchema;
+    } catch {
+      return schema;
+    }
+  }
+  extractProperties(schema) {
+    const properties = {};
+    try {
+      if (schema.type === "object" && schema.properties) {
+        for (const [key, value] of Object.entries(schema.properties)) {
+          const prop = value;
+          let type = prop.type || "unknown";
+          let enumValues;
+          if (prop.anyOf && Array.isArray(prop.anyOf)) {
+            const literals = prop.anyOf.filter(
+              (item) => item.type === "string" && item.const !== void 0
+            ).map((item) => item.const);
+            if (literals.length > 0) {
+              type = "string";
+              enumValues = literals;
+            } else {
+              const types = prop.anyOf.map((item) => item.type).filter(Boolean);
+              type = types.length > 0 ? types.join(" | ") : "union";
+            }
+          }
+          properties[key] = {
+            type,
+            description: prop.description,
+            required: schema.required?.includes(key) || false,
+            default: prop.default,
+            enum: enumValues || prop.enum,
+            pattern: prop.pattern,
+            minimum: prop.minimum,
+            maximum: prop.maximum,
+            minLength: prop.minLength,
+            maxLength: prop.maxLength
+          };
+          Object.keys(properties[key]).forEach((k) => {
+            if (properties[key][k] === void 0) {
+              delete properties[key][k];
+            }
+          });
+        }
+      }
+    } catch {
+    }
+    return properties;
+  }
+  async extractExamples(filePath) {
+    const examples = [];
+    const normalizeExampleProps = (input) => {
+      if (input && typeof input === "object" && "props" in input) {
+        return input.props;
+      }
+      return input;
+    };
+    try {
+      const content = await fs3.readFile(filePath, "utf-8");
+      const exampleRegex = /@example\s*(?:<caption>(.*?)<\/caption>)?\s*\*?\s*```(?:json|typescript|ts)?\s*([\s\S]*?)```/gi;
+      let match;
+      while ((match = exampleRegex.exec(content)) !== null) {
+        const title = match[1]?.trim();
+        let codeBlock = match[2];
+        codeBlock = codeBlock.split("\n").map((line) => line.replace(/^\s*\*\s?/, "")).join("\n").trim();
+        const jsonMatch = codeBlock.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          try {
+            const props = JSON.parse(jsonMatch[0]);
+            examples.push({
+              title,
+              props: normalizeExampleProps(props)
+            });
+          } catch {
+            const propsMatch = codeBlock.match(/props:\s*\{[\s\S]*?\}/);
+            if (propsMatch) {
+              try {
+                const configStr = propsMatch[0].replace(/props:\s*/, "");
+                const cleanConfig = configStr.replace(/(['"])?([a-zA-Z0-9_]+)(['"])?:/g, '"$2":').replace(/'/g, '"').replace(/,(\s*[}\]])/g, "$1").replace(/,\s*$/, "");
+                const props = JSON.parse(cleanConfig);
+                examples.push({ title, props });
+              } catch {
+              }
+            }
+          }
+        }
+      }
+      const inlineExampleRegex = /\/\/\s*Example:\s*(\{.*?\})/g;
+      while ((match = inlineExampleRegex.exec(content)) !== null) {
+        try {
+          const props = JSON.parse(match[1]);
+          examples.push({ props: normalizeExampleProps(props) });
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return examples;
+  }
+  async extractBatch(components) {
+    const metadataList = [];
+    for (const [filePath, component] of components) {
+      try {
+        const metadata = await this.extract(component, filePath);
+        metadataList.push(metadata);
+      } catch (error) {
+        console.warn(`Failed to extract metadata from ${filePath}:`, error);
+      }
+    }
+    return metadataList;
+  }
+};
+
+// src/utils/project-root.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+var PROJECT_ROOT_MARKERS = [
+  "pnpm-workspace.yaml",
+  "pnpm-workspace.yml",
+  "turbo.json",
+  "lerna.json",
+  "nx.json",
+  ".git",
+  "package.json"
+];
+function hasWorkspaces(packageJsonPath) {
+  try {
+    const content = fs4.readFileSync(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return !!(pkg.workspaces || pkg.private === true);
+  } catch {
+    return false;
+  }
+}
+function findProjectRoot(startPath) {
+  let currentPath = path5.resolve(startPath || process.cwd());
+  const root = path5.parse(currentPath).root;
+  while (currentPath !== root) {
+    for (const marker of PROJECT_ROOT_MARKERS) {
+      const markerPath = path5.join(currentPath, marker);
+      if (fs4.existsSync(markerPath)) {
+        if (marker === "package.json") {
+          if (hasWorkspaces(markerPath)) {
+            return currentPath;
+          }
+          continue;
+        }
+        return currentPath;
+      }
+    }
+    const parentPath = path5.dirname(currentPath);
+    if (parentPath === currentPath) break;
+    currentPath = parentPath;
+  }
+  const fallbackPackageJson = path5.join(
+    startPath || process.cwd(),
+    "package.json"
+  );
+  if (fs4.existsSync(fallbackPackageJson)) {
+    return startPath || process.cwd();
+  }
+  return null;
+}
+function getProjectRoot(startPath) {
+  const root = findProjectRoot(startPath);
+  if (!root) {
+    console.warn(
+      "Warning: Could not detect project root, using current directory"
+    );
+    return process.cwd();
+  }
+  return root;
+}
+function isWithinProject(targetPath, projectRoot) {
+  const resolvedTarget = path5.resolve(targetPath);
+  const resolvedRoot = path5.resolve(projectRoot);
+  return resolvedTarget.startsWith(resolvedRoot);
+}
+function resolveScopePath(scope, projectRoot) {
+  const resolved = path5.resolve(projectRoot, scope);
+  if (!isWithinProject(resolved, projectRoot)) {
+    throw new Error(`Scope path "${scope}" is outside the project root`);
+  }
+  if (!fs4.existsSync(resolved)) {
+    throw new Error(`Scope directory not found: ${scope}`);
+  }
+  const stats = fs4.statSync(resolved);
+  if (!stats.isDirectory()) {
+    throw new Error(`Scope must be a directory, not a file: ${scope}`);
+  }
+  return resolved;
+}
+
+// src/services/plugin-discovery.ts
+var PluginDiscoveryService = class {
+  scanner;
+  loader;
+  metadataExtractor;
+  options;
+  searchPath;
+  projectRoot;
+  constructor(options = {}) {
+    this.options = options;
+    this.scanner = new FileSystemScanner();
+    this.loader = new PluginLoader();
+    this.projectRoot = getProjectRoot();
+    if (options.scope) {
+      try {
+        this.searchPath = resolveScopePath(options.scope, this.projectRoot);
+      } catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+      }
+    } else {
+      this.searchPath = this.projectRoot;
+    }
+    this.metadataExtractor = new PluginMetadataExtractor(this.searchPath);
+  }
+  async discover() {
+    return this.discoverPlugins();
+  }
+  async discoverPlugins() {
+    const startPath = this.searchPath;
+    try {
+      await this.loader.initialize();
+      const allPluginPaths = await this.searchDownstream(startPath, "plugin");
+      const uniquePaths = this.scanner.deduplicatePaths(allPluginPaths);
+      if (this.options.verbose) {
+        console.log(`Found ${uniquePaths.length} potential plugin files`);
+      }
+      const loadedModules = await this.loader.loadPlugins(uniquePaths);
+      if (this.options.verbose) {
+        console.log(`Successfully loaded ${loadedModules.size} plugins`);
+      }
+      const metadata = await this.metadataExtractor.extractBatch(loadedModules);
+      metadata.sort((a, b) => {
+        const locationOrder = {
+          current: 0,
+          downstream: 1,
+          upstream: 2
+        };
+        const locationDiff = locationOrder[a.location] - locationOrder[b.location];
+        if (locationDiff !== 0) return locationDiff;
+        return a.name.localeCompare(b.name);
+      });
+      return metadata;
+    } finally {
+      this.loader.cleanup();
+    }
+  }
+  async discoverDocuments(format) {
+    const startPath = this.searchPath;
+    const discoveryType = format === "pptx" ? "pptx-document" : "docx-document";
+    const ext = format === "pptx" ? ".pptx.json" : ".docx.json";
+    const allDocumentPaths = await this.searchDownstream(startPath, discoveryType);
+    const uniquePaths = this.scanner.deduplicatePaths(allDocumentPaths);
+    const metadata = [];
+    for (const docPath of uniquePaths) {
+      try {
+        const content = await fs5.readFile(docPath, "utf-8");
+        const json = JSON.parse(content);
+        const location = this.getFileLocation(docPath, startPath);
+        metadata.push({
+          name: path6.basename(docPath, ext),
+          path: docPath,
+          location,
+          type: json.name || "document",
+          title: json.props?.title || json.title,
+          description: json.props?.metadata?.description || json.description,
+          theme: json.props?.theme || json.theme
+        });
+      } catch {
+      }
+    }
+    metadata.sort((a, b) => {
+      const locationOrder = { current: 0, downstream: 1, upstream: 2 };
+      const locationDiff = locationOrder[a.location] - locationOrder[b.location];
+      if (locationDiff !== 0) return locationDiff;
+      return a.name.localeCompare(b.name);
+    });
+    return metadata;
+  }
+  async discoverThemes(format) {
+    const startPath = this.searchPath;
+    const discoveryType = format === "pptx" ? "pptx-theme" : "docx-theme";
+    const ext = format === "pptx" ? ".pptx.theme.json" : ".docx.theme.json";
+    const allThemePaths = await this.searchDownstream(startPath, discoveryType);
+    const uniquePaths = this.scanner.deduplicatePaths(allThemePaths);
+    const metadata = [];
+    for (const themePath of uniquePaths) {
+      try {
+        const content = await fs5.readFile(themePath, "utf-8");
+        const json = JSON.parse(content);
+        const location = this.getFileLocation(themePath, startPath);
+        metadata.push({
+          name: path6.basename(themePath, ext),
+          path: themePath,
+          location,
+          description: json.description || json.metadata?.description
+        });
+      } catch {
+      }
+    }
+    metadata.sort((a, b) => {
+      const locationOrder = { current: 0, downstream: 1, upstream: 2 };
+      const locationDiff = locationOrder[a.location] - locationOrder[b.location];
+      if (locationDiff !== 0) return locationDiff;
+      return a.name.localeCompare(b.name);
+    });
+    return metadata;
+  }
+  async getDocumentContent(name, format) {
+    const documents = await this.discoverDocuments(format);
+    const document = documents.find((doc) => doc.name === name);
+    if (!document) throw new Error(`Document '${name}' not found`);
+    return await fs5.readFile(document.path, "utf-8");
+  }
+  async getThemeContent(name, format) {
+    const themes = await this.discoverThemes(format);
+    const theme = themes.find((t) => t.name === name);
+    if (!theme) throw new Error(`Theme '${name}' not found`);
+    return await fs5.readFile(theme.path, "utf-8");
+  }
+  async discoverAll(format) {
+    const [plugins, documents, themes] = await Promise.all([
+      this.discoverPlugins(),
+      this.discoverDocuments(format),
+      this.discoverThemes(format)
+    ]);
+    return { plugins, documents, themes };
+  }
+  getFileLocation(filePath, startPath) {
+    const relative3 = path6.relative(startPath, filePath);
+    if (relative3 === path6.basename(filePath)) {
+      return "current";
+    }
+    return "downstream";
+  }
+  async searchDownstream(startPath, fileType = "plugin") {
+    const resolvedPath = path6.resolve(startPath);
+    const plugins = await this.scanner.scan(resolvedPath, fileType, {
+      maxDepth: this.options.maxDepth || 10,
+      excludeNodeModules: !this.options.includeNodeModules
+    });
+    if (await this.scanner.hasPackageJson(resolvedPath)) {
+      const monorepoPlugins = await this.scanner.scanMonorepoLocations(
+        resolvedPath,
+        fileType
+      );
+      const downstreamMonorepoPlugins = monorepoPlugins.filter((p) => {
+        const relative3 = path6.relative(resolvedPath, p);
+        return !relative3.startsWith("..");
+      });
+      plugins.push(...downstreamMonorepoPlugins);
+    }
+    return plugins;
+  }
+  async hasPlugins() {
+    const plugins = await this.discoverPlugins();
+    return plugins.length > 0;
+  }
+  async getPluginByName(name) {
+    const plugins = await this.discoverPlugins();
+    return plugins.find((p) => p.name === name);
+  }
+};
+
+// src/services/plugin-registry.ts
+import * as path7 from "path";
+
+// src/services/cache-events.ts
+import { EventEmitter } from "events";
+var CacheEventEmitter = class extends EventEmitter {
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+};
+var cacheEvents = new CacheEventEmitter();
+function invalidateAllCaches() {
+  cacheEvents.emit("cache:invalidate");
+  cacheEvents.emit("schema:invalidate");
+  cacheEvents.emit("generator:invalidate");
+}
+
+// src/services/plugin-registry.ts
+var PluginRegistry = class _PluginRegistry {
+  static instance;
+  plugins = /* @__PURE__ */ new Map();
+  pluginPaths = /* @__PURE__ */ new Map();
+  pluginMetadata = /* @__PURE__ */ new Map();
+  loader;
+  discoveryService;
+  constructor() {
+    this.loader = new PluginLoader();
+    this.discoveryService = new PluginDiscoveryService();
+  }
+  static getInstance() {
+    if (!_PluginRegistry.instance) {
+      _PluginRegistry.instance = new _PluginRegistry();
+    }
+    return _PluginRegistry.instance;
+  }
+  notifyCacheInvalidation() {
+    try {
+      invalidateAllCaches();
+    } catch {
+    }
+  }
+  async loadPlugin(pathOrName) {
+    try {
+      await this.loader.initialize();
+      const pluginPath = await this.resolvePluginPath(pathOrName);
+      if (!pluginPath) {
+        throw new Error(`Plugin '${pathOrName}' not found`);
+      }
+      const module = await this.loader.loadPlugin(pluginPath);
+      if (module) {
+        this.plugins.set(module.name, module);
+        this.pluginPaths.set(module.name, pluginPath);
+        this.notifyCacheInvalidation();
+      } else {
+        throw new Error(`Failed to load valid component from ${pluginPath}`);
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to load plugin '${pathOrName}': ${error.message}`
+      );
+    }
+  }
+  async loadPlugins(pathsOrNames) {
+    const errors = [];
+    try {
+      for (const pathOrName of pathsOrNames) {
+        try {
+          await this.loadPlugin(pathOrName);
+        } catch (error) {
+          errors.push(error.message);
+        }
+      }
+      if (errors.length > 0) {
+        throw new Error(
+          `Failed to load ${errors.length} plugin(s): ${errors.join("; ")}`
+        );
+      }
+    } finally {
+      this.loader.cleanup();
+    }
+  }
+  async loadPluginsFromMetadata(pluginMetadata) {
+    let loadedCount = 0;
+    for (const metadata of pluginMetadata) {
+      try {
+        const pluginPath = metadata.filePath;
+        const module = await this.loader.loadPlugin(pluginPath);
+        if (module) {
+          this.plugins.set(module.name, module);
+          this.pluginPaths.set(module.name, pluginPath);
+          this.pluginMetadata.set(module.name, metadata);
+          loadedCount++;
+          this.notifyCacheInvalidation();
+        }
+      } catch {
+      }
+    }
+    return loadedCount;
+  }
+  async loadPluginsFromDirectory(dir) {
+    try {
+      await this.loader.initialize();
+      const discovery = new PluginDiscoveryService({
+        scope: dir,
+        maxDepth: 5
+      });
+      const pluginMetadata = await discovery.discover();
+      return await this.loadPluginsFromMetadata(pluginMetadata);
+    } catch (error) {
+      throw new Error(
+        `Failed to load plugins from directory: ${error.message}`
+      );
+    } finally {
+      this.loader.cleanup();
+    }
+  }
+  async discoverAndLoad() {
+    try {
+      await this.loader.initialize();
+      const pluginMetadata = await this.discoveryService.discover();
+      const discovered = pluginMetadata.length;
+      if (discovered === 0) {
+        return { discovered: 0, loaded: 0 };
+      }
+      const loaded = await this.loadPluginsFromMetadata(pluginMetadata);
+      return { discovered, loaded };
+    } catch (error) {
+      throw new Error(`Failed to discover and load plugins: ${error.message}`);
+    } finally {
+      this.loader.cleanup();
+    }
+  }
+  async resolvePluginName(name) {
+    if (this.pluginPaths.has(name)) {
+      return this.pluginPaths.get(name);
+    }
+    try {
+      const pluginMetadata = await this.discoveryService.discover();
+      const metadata = pluginMetadata.find((p) => p.name === name);
+      if (metadata) return metadata.filePath;
+    } catch {
+    }
+    return void 0;
+  }
+  async resolvePluginPath(pathOrName) {
+    if (pathOrName.endsWith(".ts") || pathOrName.endsWith(".js")) {
+      return path7.resolve(process.cwd(), pathOrName);
+    }
+    return await this.resolvePluginName(pathOrName);
+  }
+  getPlugins() {
+    return Array.from(this.plugins.values());
+  }
+  getPluginNames() {
+    return Array.from(this.plugins.keys());
+  }
+  getPlugin(name) {
+    return this.plugins.get(name);
+  }
+  hasPlugins() {
+    return this.plugins.size > 0;
+  }
+  getPluginCount() {
+    return this.plugins.size;
+  }
+  clear() {
+    this.plugins.clear();
+    this.pluginPaths.clear();
+    this.pluginMetadata.clear();
+    this.loader.cleanup();
+    this.notifyCacheInvalidation();
+  }
+  static cleanup() {
+    if (_PluginRegistry.instance) {
+      _PluginRegistry.instance.clear();
+    }
+  }
+  getPluginMetadata(name) {
+    return this.pluginMetadata.get(name);
+  }
+  getAllPluginMetadata() {
+    return Array.from(this.pluginMetadata.values());
+  }
+};
+
+// src/services/generator-factory.ts
+var GeneratorFactory = class {
+  registry;
+  adapter;
+  constructor(adapter) {
+    this.registry = PluginRegistry.getInstance();
+    this.adapter = adapter;
+  }
+  async createGenerator(options = {}) {
+    const plugins = this.registry.getPlugins();
+    return this.adapter.createGenerator(plugins, options);
+  }
+  async generate(document, options = {}) {
+    const generator = await this.createGenerator(options);
+    return await generator.generateBuffer(document);
+  }
+  getPluginInfo() {
+    return {
+      hasPlugins: this.registry.hasPlugins(),
+      count: this.registry.getPluginCount(),
+      names: this.registry.getPluginNames()
+    };
+  }
+};
+
+// src/services/plugin-resolver.ts
+import * as fs6 from "fs/promises";
+import * as path8 from "path";
+var PluginResolver = class {
+  discoveryService;
+  discoveredPlugins = /* @__PURE__ */ new Map();
+  lastDiscoveryTime = 0;
+  CACHE_DURATION = 5 * 60 * 1e3;
+  constructor() {
+    this.discoveryService = new PluginDiscoveryService();
+  }
+  async resolve(input) {
+    const pathResult = await this.resolveAsPath(input);
+    if (pathResult) return pathResult;
+    const nameResult = await this.resolveAsName(input);
+    if (nameResult) return nameResult;
+    await this.refreshDiscoveryCache();
+    const discoveredResult = await this.resolveAsName(input);
+    if (discoveredResult) return discoveredResult;
+    throw await this.createNotFoundError(input);
+  }
+  async resolveMultiple(inputs) {
+    const resolved = /* @__PURE__ */ new Map();
+    const errors = [];
+    for (const input of inputs) {
+      try {
+        const resolvedPath = await this.resolve(input);
+        resolved.set(input, resolvedPath);
+      } catch (error) {
+        errors.push(`${input}: ${error.message}`);
+      }
+    }
+    if (errors.length > 0 && errors.length === inputs.length) {
+      throw new Error(`Failed to resolve plugins:
+${errors.join("\n")}`);
+    }
+    return resolved;
+  }
+  async resolveAsPath(input) {
+    if (!this.looksLikePath(input)) return null;
+    const resolvedPath = path8.resolve(process.cwd(), input);
+    try {
+      const stats = await fs6.stat(resolvedPath);
+      if (stats.isFile()) return resolvedPath;
+    } catch {
+    }
+    return null;
+  }
+  async resolveAsName(name) {
+    if (this.discoveredPlugins.size === 0 || this.isCacheExpired()) {
+      await this.refreshDiscoveryCache();
+    }
+    const plugin = this.discoveredPlugins.get(name);
+    if (plugin) return plugin.filePath;
+    const lowerName = name.toLowerCase();
+    for (const [pluginName, metadata] of this.discoveredPlugins) {
+      if (pluginName.toLowerCase() === lowerName) return metadata.filePath;
+    }
+    return null;
+  }
+  async refreshDiscoveryCache() {
+    try {
+      const plugins = await this.discoveryService.discover();
+      this.discoveredPlugins.clear();
+      for (const plugin of plugins) {
+        this.discoveredPlugins.set(plugin.name, plugin);
+      }
+      this.lastDiscoveryTime = Date.now();
+    } catch (error) {
+      console.warn(`Plugin discovery failed: ${error.message}`);
+    }
+  }
+  isCacheExpired() {
+    return Date.now() - this.lastDiscoveryTime > this.CACHE_DURATION;
+  }
+  looksLikePath(input) {
+    if (input.endsWith(".ts") || input.endsWith(".js")) return true;
+    if (input.includes("/") || input.includes("\\")) return true;
+    if (input.startsWith("./") || input.startsWith("../")) return true;
+    if (path8.isAbsolute(input)) return true;
+    return false;
+  }
+  async createNotFoundError(input) {
+    let message = `Plugin '${input}' not found.`;
+    if (this.discoveredPlugins.size > 0) {
+      const suggestions = this.findSimilarNames(input);
+      if (suggestions.length > 0) {
+        message += "\n\nDid you mean one of these?";
+        suggestions.forEach((name) => {
+          message += `
+  - ${name}`;
+        });
+      } else {
+        message += "\n\nAvailable plugins:";
+        Array.from(this.discoveredPlugins.keys()).slice(0, 5).forEach((name) => {
+          message += `
+  - ${name}`;
+        });
+        if (this.discoveredPlugins.size > 5) {
+          message += `
+  ... and ${this.discoveredPlugins.size - 5} more`;
+        }
+      }
+    }
+    message += "\n\nUse 'jto <format> discover' to list all available plugins.";
+    return new Error(message);
+  }
+  findSimilarNames(input) {
+    const inputLower = input.toLowerCase();
+    const suggestions = [];
+    for (const name of this.discoveredPlugins.keys()) {
+      const nameLower = name.toLowerCase();
+      if (nameLower.includes(inputLower) || inputLower.includes(nameLower)) {
+        suggestions.push(name);
+      } else if (nameLower.startsWith(inputLower[0])) {
+        suggestions.push(name);
+      }
+      if (suggestions.length >= 3) break;
+    }
+    return suggestions;
+  }
+  async getAvailablePluginNames() {
+    if (this.discoveredPlugins.size === 0 || this.isCacheExpired()) {
+      await this.refreshDiscoveryCache();
+    }
+    return Array.from(this.discoveredPlugins.keys());
+  }
+  clearCache() {
+    this.discoveredPlugins.clear();
+    this.lastDiscoveryTime = 0;
+  }
+};
+
+// src/services/schema-generator.ts
+import * as path9 from "path";
+import * as fs8 from "fs/promises";
+
+// src/services/typebox-exporter.ts
+import * as fs7 from "fs/promises";
+var TypeBoxExporter = class {
+  formatName;
+  constructor(formatName = "docx") {
+    this.formatName = formatName;
+  }
+  get sharedPackage() {
+    return this.formatName === "docx" ? "@json-to-office/shared-docx" : "@json-to-office/shared-pptx";
+  }
+  async exportDocumentSchema(schema, outputPath, customComponents) {
+    const hasCustomComponents = customComponents.length > 0;
+    const content = [
+      "/**",
+      ` * Generated TypeBox Document Schema (${this.formatName.toUpperCase()})`,
+      hasCustomComponents ? " * Includes standard components and custom plugin components" : " * Includes standard components only",
+      " * Generated on: " + (/* @__PURE__ */ new Date()).toISOString(),
+      " */",
+      "",
+      "import { Type, type Static } from '@sinclair/typebox';",
+      `// Import component schemas from '${this.sharedPackage}'`,
+      "",
+      "export const DocumentSchema = Type.Any(); // TODO: generate full recursive schema",
+      "",
+      "export type DocumentType = Static<typeof DocumentSchema>;",
+      ""
+    ].join("\n");
+    await fs7.writeFile(outputPath, content, "utf-8");
+  }
+  async exportThemeSchema(schema, outputPath) {
+    const content = [
+      "/**",
+      ` * Generated TypeBox Theme Schema (${this.formatName.toUpperCase()})`,
+      " * Generated on: " + (/* @__PURE__ */ new Date()).toISOString(),
+      " */",
+      "",
+      "import { type Static } from '@sinclair/typebox';",
+      "",
+      `export { ThemeConfigSchema } from '${this.sharedPackage}';`,
+      "",
+      `import { ThemeConfigSchema } from '${this.sharedPackage}';`,
+      "export type ThemeType = Static<typeof ThemeConfigSchema>;",
+      ""
+    ].join("\n");
+    await fs7.writeFile(outputPath, content, "utf-8");
+  }
+  async exportComponentSchema(componentName, schema, outputPath, metadata) {
+    const pascalName = this.toPascalCase(componentName);
+    const content = [
+      "/**",
+      ` * Generated TypeBox Component Schema: ${componentName}`,
+      metadata?.description ? ` * ${metadata.description}` : "",
+      " * Generated on: " + (/* @__PURE__ */ new Date()).toISOString(),
+      " */",
+      "",
+      "import { Type, type Static } from '@sinclair/typebox';",
+      "",
+      `export const ${pascalName}ComponentSchema = Type.Object({`,
+      `  name: Type.Literal('${componentName}'),`,
+      "  id: Type.Optional(Type.String()),",
+      "  props: Type.Any(),",
+      "});",
+      "",
+      `export type ${pascalName}ComponentType = Static<typeof ${pascalName}ComponentSchema>;`,
+      ""
+    ].filter((line) => line !== "").join("\n");
+    await fs7.writeFile(outputPath, content, "utf-8");
+  }
+  toPascalCase(str) {
+    return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
+};
+
+// src/services/schema-generator.ts
+var SchemaGenerator = class {
+  registry;
+  typeboxExporter;
+  formatName;
+  constructor(formatName = "docx") {
+    this.registry = PluginRegistry.getInstance();
+    this.typeboxExporter = new TypeBoxExporter(formatName);
+    this.formatName = formatName;
+  }
+  async generateAndExportSchemas(outputDir, options = {}) {
+    const {
+      includeDocument = true,
+      includeTheme = true,
+      split = false,
+      format = "json"
+    } = options;
+    const results = {};
+    await fs8.mkdir(outputDir, { recursive: true });
+    const customComponents = this.getCustomComponents();
+    if (includeDocument) {
+      const documentPath = await this.generateDocumentSchema(
+        outputDir,
+        customComponents,
+        format
+      );
+      results.document = documentPath;
+    }
+    if (includeTheme) {
+      const themePath = await this.generateThemeSchema(outputDir, format);
+      results.theme = themePath;
+    }
+    if (split) {
+      const componentPaths = await this.generateComponentSchemas(
+        outputDir,
+        customComponents,
+        format
+      );
+      results.components = componentPaths;
+    }
+    return results;
+  }
+  async generateDocumentSchema(outputDir, customComponents, format) {
+    if (this.formatName === "docx") {
+      const { generateUnifiedDocumentSchema } = await import("@json-to-office/shared-docx");
+      const schema = generateUnifiedDocumentSchema({
+        includeStandardComponents: true,
+        includeTheme: false,
+        customComponents: customComponents.map((m) => ({
+          name: m.name,
+          propsSchema: m.propsSchema,
+          hasChildren: m.hasChildren,
+          versionedProps: m.versionedProps
+        })),
+        title: "JSON Document Definition",
+        description: customComponents.length > 0 ? "Document definition with standard and custom plugin components" : "Document definition with standard components"
+      });
+      if (format === "json") {
+        const { convertToJsonSchema, exportSchemaToFile } = await import("@json-to-office/shared");
+        const jsonSchema = convertToJsonSchema(schema, {
+          $id: "document.schema.json"
+        });
+        const outputPath = path9.join(outputDir, "document.schema.json");
+        await exportSchemaToFile(jsonSchema, outputPath, { prettyPrint: true });
+        return outputPath;
+      } else {
+        const outputPath = path9.join(outputDir, "document.schema.ts");
+        await this.typeboxExporter.exportDocumentSchema(
+          schema,
+          outputPath,
+          customComponents
+        );
+        return outputPath;
+      }
+    } else {
+      const { generateUnifiedDocumentSchema } = await import("@json-to-office/shared-pptx");
+      const schema = generateUnifiedDocumentSchema({
+        customComponents: customComponents.map((m) => ({
+          name: m.name,
+          versions: m.versionedProps ? m.versionedProps.map((vp) => ({
+            version: vp.version,
+            propsSchema: vp.propsSchema,
+            hasChildren: vp.hasChildren
+          })) : [
+            {
+              version: "1.0.0",
+              propsSchema: m.propsSchema,
+              hasChildren: m.hasChildren
+            }
+          ]
+        }))
+      });
+      if (format === "json") {
+        const { convertToJsonSchema, exportSchemaToFile } = await import("@json-to-office/shared");
+        const jsonSchema = convertToJsonSchema(schema, {
+          $id: "presentation.schema.json"
+        });
+        const outputPath = path9.join(outputDir, "presentation.schema.json");
+        await exportSchemaToFile(jsonSchema, outputPath, { prettyPrint: true });
+        return outputPath;
+      } else {
+        const outputPath = path9.join(outputDir, "presentation.schema.ts");
+        await this.typeboxExporter.exportDocumentSchema(
+          schema,
+          outputPath,
+          customComponents
+        );
+        return outputPath;
+      }
+    }
+  }
+  async generateThemeSchema(outputDir, format) {
+    const sharedPkg = this.formatName === "docx" ? "@json-to-office/shared-docx" : "@json-to-office/shared-pptx";
+    const shared = await import(sharedPkg);
+    const ThemeConfigSchema = shared.ThemeConfigSchema;
+    if (format === "json") {
+      const { convertToJsonSchema, exportSchemaToFile } = await import("@json-to-office/shared");
+      const jsonSchema = convertToJsonSchema(ThemeConfigSchema, {
+        $id: "theme.schema.json",
+        title: "Theme Configuration",
+        description: "Theme configuration for styling"
+      });
+      const outputPath = path9.join(outputDir, "theme.schema.json");
+      await exportSchemaToFile(jsonSchema, outputPath, { prettyPrint: true });
+      return outputPath;
+    } else {
+      const outputPath = path9.join(outputDir, "theme.schema.ts");
+      await this.typeboxExporter.exportThemeSchema(
+        ThemeConfigSchema,
+        outputPath
+      );
+      return outputPath;
+    }
+  }
+  async generateComponentSchemas(outputDir, customComponents, format) {
+    const componentsDir = path9.join(outputDir, "components");
+    await fs8.mkdir(componentsDir, { recursive: true });
+    const paths = [];
+    const standardComponents = await this.getStandardComponentSchemas();
+    for (const [type, schema] of Object.entries(standardComponents)) {
+      if (format === "json") {
+        const { convertToJsonSchema, exportSchemaToFile } = await import("@json-to-office/shared");
+        const jsonSchema = convertToJsonSchema(schema, {
+          $id: `${type}.schema.json`,
+          title: `${type} Component`,
+          description: `${type} component configuration`
+        });
+        const outputPath = path9.join(componentsDir, `${type}.schema.json`);
+        await exportSchemaToFile(jsonSchema, outputPath, { prettyPrint: true });
+        paths.push(outputPath);
+      } else {
+        const outputPath = path9.join(componentsDir, `${type}.schema.ts`);
+        await this.typeboxExporter.exportComponentSchema(type, schema, outputPath);
+        paths.push(outputPath);
+      }
+    }
+    for (const customComponent of customComponents) {
+      if (format === "json") {
+        const { convertToJsonSchema, exportSchemaToFile } = await import("@json-to-office/shared");
+        const jsonSchema = convertToJsonSchema(customComponent.propsSchema, {
+          $id: `${customComponent.name}.schema.json`,
+          title: `${customComponent.name} Component`,
+          description: `Custom ${customComponent.name} component configuration`
+        });
+        const outputPath = path9.join(
+          componentsDir,
+          `${customComponent.name}.schema.json`
+        );
+        await exportSchemaToFile(jsonSchema, outputPath, { prettyPrint: true });
+        paths.push(outputPath);
+      } else {
+        const outputPath = path9.join(
+          componentsDir,
+          `${customComponent.name}.schema.ts`
+        );
+        await this.typeboxExporter.exportComponentSchema(
+          customComponent.name,
+          customComponent.propsSchema,
+          outputPath
+        );
+        paths.push(outputPath);
+      }
+    }
+    return paths;
+  }
+  async getStandardComponentSchemas() {
+    if (this.formatName === "docx") {
+      const shared = await import("@json-to-office/shared-docx");
+      return {
+        report: shared.ReportPropsSchema,
+        section: shared.SectionPropsSchema,
+        columns: shared.ColumnsPropsSchema,
+        heading: shared.HeadingPropsSchema,
+        paragraph: shared.ParagraphPropsSchema,
+        image: shared.ImagePropsSchema,
+        statistic: shared.StatisticPropsSchema,
+        table: shared.TablePropsSchema,
+        header: shared.HeaderPropsSchema,
+        footer: shared.FooterPropsSchema,
+        list: shared.ListPropsSchema
+      };
+    } else {
+      const shared = await import("@json-to-office/shared-pptx");
+      return {
+        presentation: shared.PresentationPropsSchema,
+        slide: shared.SlidePropsSchema,
+        text: shared.TextPropsSchema,
+        image: shared.PptxImagePropsSchema,
+        shape: shared.ShapePropsSchema,
+        table: shared.PptxTablePropsSchema
+      };
+    }
+  }
+  getCustomComponents() {
+    const loadedPlugins = this.registry.getPlugins();
+    const customComponents = [];
+    for (const plugin of loadedPlugins) {
+      const component = plugin;
+      const versions = component.versions;
+      if (component.name && versions && typeof versions === "object") {
+        const versionKeys = Object.keys(versions);
+        if (versionKeys.length > 0) {
+          const versionedProps = versionKeys.map((v) => ({
+            version: v,
+            propsSchema: versions[v].propsSchema,
+            hasChildren: versions[v].hasChildren === true
+          }));
+          const hasChildren = versionKeys.some(
+            (v) => versions[v].hasChildren === true
+          );
+          const latestKey = versionKeys.reduce((a, b) => a > b ? a : b);
+          customComponents.push({
+            name: component.name,
+            propsSchema: versions[latestKey].propsSchema,
+            hasChildren,
+            versionedProps
+          });
+        }
+      }
+    }
+    return customComponents;
+  }
+};
+
+// src/services/json-validator.ts
+import { readFileSync as readFileSync3, statSync as statSync2, readdirSync } from "fs";
+import { resolve as resolve8, join as join4, extname } from "path";
+import * as glob2 from "glob";
+var JsonValidator = class {
+  format;
+  constructor(format = "docx") {
+    this.format = format;
+  }
+  async validate(pathOrPattern, options = {}) {
+    const results = [];
+    const files = await this.getFilesToValidate(pathOrPattern, options);
+    for (const file of files) {
+      const result = await this.validateFile(file, options);
+      results.push(result);
+    }
+    return results;
+  }
+  async validateFile(filePath, options = {}) {
+    const absolutePath = resolve8(filePath);
+    try {
+      const content = readFileSync3(absolutePath, "utf-8");
+      let jsonData;
+      try {
+        jsonData = JSON.parse(content);
+      } catch (error) {
+        return {
+          file: filePath,
+          valid: false,
+          errors: [
+            {
+              path: "root",
+              message: `Invalid JSON: ${error.message}`,
+              code: "json_parse_error"
+            }
+          ]
+        };
+      }
+      const validationType = options.type === "auto" || !options.type ? this.detectType(jsonData) : options.type;
+      if (options.schema) {
+        return await this.validateWithCustomSchema(
+          filePath,
+          jsonData,
+          options.schema,
+          options.strict
+        );
+      } else if (validationType === "document") {
+        return await this.validateAsDocument(
+          filePath,
+          jsonData,
+          content,
+          options.strict
+        );
+      } else if (validationType === "theme") {
+        return await this.validateAsTheme(
+          filePath,
+          jsonData,
+          content,
+          options.strict
+        );
+      } else {
+        return {
+          file: filePath,
+          valid: false,
+          errors: [
+            {
+              path: "root",
+              message: "Could not determine JSON type (document or theme). Use --type to specify.",
+              code: "unknown_type"
+            }
+          ]
+        };
+      }
+    } catch (error) {
+      return {
+        file: filePath,
+        valid: false,
+        errors: [
+          {
+            path: "file",
+            message: error.message,
+            code: "file_error"
+          }
+        ]
+      };
+    }
+  }
+  async validateAsDocument(filePath, jsonData, jsonString, strict) {
+    try {
+      if (this.format === "docx") {
+        const { validate, validateStrict } = await import("@json-to-office/shared-docx");
+        const validator = strict ? validateStrict : validate;
+        const result = validator.jsonDocument(jsonString);
+        return {
+          file: filePath,
+          valid: result.valid,
+          type: "document",
+          errors: result.errors?.map((e) => ({
+            ...e,
+            code: e.code || "VALIDATION_ERROR"
+          })),
+          warnings: result.warnings?.map((e) => ({
+            ...e,
+            code: e.code || "WARNING"
+          }))
+        };
+      } else {
+        return {
+          file: filePath,
+          valid: true,
+          type: "document"
+        };
+      }
+    } catch {
+      return { file: filePath, valid: true, type: "document" };
+    }
+  }
+  async validateAsTheme(filePath, jsonData, jsonString, strict) {
+    try {
+      if (this.format === "docx") {
+        const { validate, validateStrict } = await import("@json-to-office/shared-docx");
+        const validator = strict ? validateStrict : validate;
+        const result = validator.jsonTheme(jsonString);
+        return {
+          file: filePath,
+          valid: result.valid,
+          type: "theme",
+          errors: result.errors?.map((e) => ({
+            ...e,
+            code: e.code || "VALIDATION_ERROR"
+          }))
+        };
+      } else {
+        return { file: filePath, valid: true, type: "theme" };
+      }
+    } catch {
+      return { file: filePath, valid: true, type: "theme" };
+    }
+  }
+  async validateWithCustomSchema(filePath, jsonData, schemaPath, strict) {
+    try {
+      const schemaContent = readFileSync3(resolve8(schemaPath), "utf-8");
+      const schema = JSON.parse(schemaContent);
+      const Ajv = (await import("ajv")).default;
+      const addFormats = (await import("ajv-formats")).default;
+      const ajv = new Ajv({
+        allErrors: true,
+        verbose: true,
+        strict: strict ?? false
+      });
+      addFormats(ajv);
+      const validate = ajv.compile(schema);
+      const valid = validate(jsonData);
+      const errors = validate.errors?.map((error) => ({
+        path: error.instancePath || "root",
+        message: error.message || "Validation error",
+        code: error.keyword || "validation_error",
+        value: error.data
+      })) || [];
+      return {
+        file: filePath,
+        valid,
+        type: "custom",
+        errors: valid ? void 0 : errors
+      };
+    } catch (error) {
+      return {
+        file: filePath,
+        valid: false,
+        type: "custom",
+        errors: [
+          {
+            path: "schema",
+            message: `Failed to load or compile schema: ${error.message}`,
+            code: "schema_error"
+          }
+        ]
+      };
+    }
+  }
+  detectType(jsonData) {
+    if (jsonData.name === "docx" || jsonData.name === "pptx" || jsonData.children && Array.isArray(jsonData.children) || jsonData.slides && Array.isArray(jsonData.slides) || jsonData.props && jsonData.props.metadata?.title) {
+      return "document";
+    }
+    if (jsonData.colors || jsonData.fonts || jsonData.styles || jsonData.pageSetup || jsonData.componentDefaults || jsonData.name && (jsonData.colors || jsonData.fonts)) {
+      return "theme";
+    }
+    return null;
+  }
+  async getFilesToValidate(pathOrPattern, options) {
+    const resolvedPath = resolve8(pathOrPattern);
+    try {
+      const stats = statSync2(resolvedPath);
+      if (stats.isFile()) {
+        return [resolvedPath];
+      } else if (stats.isDirectory()) {
+        if (options.recursive) {
+          const pattern = join4(resolvedPath, "**/*.json");
+          return glob2.glob(pattern, {
+            ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"]
+          });
+        } else {
+          const files = readdirSync(resolvedPath);
+          return files.filter((file) => extname(file).toLowerCase() === ".json").map((file) => join4(resolvedPath, file));
+        }
+      }
+    } catch {
+      return glob2.glob(pathOrPattern, {
+        ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"]
+      });
+    }
+    return [];
+  }
+  formatError(error, indent = 0) {
+    const spaces = " ".repeat(indent);
+    let output = `${spaces}* ${error.path}: ${error.message}`;
+    if (error.line && error.column) {
+      output += ` (line ${error.line}, column ${error.column})`;
+    }
+    if (error.suggestion) {
+      output += `
+${spaces}  -> ${error.suggestion}`;
+    }
+    return output;
+  }
+  formatResultsAsJson(results) {
+    return JSON.stringify(results, null, 2);
+  }
+};
+
+// src/config/plugin-config.ts
+import * as fs9 from "fs/promises";
+import * as path10 from "path";
+import { cosmiconfig } from "cosmiconfig";
+var PluginConfigService = class _PluginConfigService {
+  static instance;
+  config = null;
+  configPath = null;
+  static CONFIG_FILES = [
+    ".json-to-office.config.json",
+    ".json-to-office.config.js",
+    "json-to-office.config.json",
+    "json-to-office.config.js",
+    ".json-to-officerc",
+    ".json-to-officerc.json",
+    ".json-to-officerc.js",
+    // Legacy support
+    ".json-to-docx.config.json",
+    ".json-to-docx.config.js",
+    "json-to-docx.config.json",
+    ".json-to-pptx.config.json",
+    ".json-to-pptx.config.js",
+    "json-to-pptx.config.json"
+  ];
+  constructor() {
+  }
+  static getInstance() {
+    if (!_PluginConfigService.instance) {
+      _PluginConfigService.instance = new _PluginConfigService();
+    }
+    return _PluginConfigService.instance;
+  }
+  async loadConfig(startPath) {
+    try {
+      const explorer = cosmiconfig("json-to-office", {
+        searchPlaces: _PluginConfigService.CONFIG_FILES,
+        stopDir: path10.parse(startPath || process.cwd()).root
+      });
+      const result = await explorer.search(startPath);
+      if (result) {
+        this.config = result.config;
+        this.configPath = result.filepath;
+        return this.config;
+      }
+    } catch (error) {
+      console.warn(`Failed to load configuration: ${error.message}`);
+    }
+    const packageConfig = await this.loadFromPackageJson(startPath);
+    if (packageConfig) {
+      this.config = packageConfig;
+      return this.config;
+    }
+    return null;
+  }
+  async loadFromPackageJson(startPath) {
+    try {
+      const packagePath = path10.join(startPath || process.cwd(), "package.json");
+      const packageContent = await fs9.readFile(packagePath, "utf-8");
+      const packageJson = JSON.parse(packageContent);
+      const config = packageJson["json-to-office"] || packageJson["json-to-docx"] || packageJson["json-to-pptx"];
+      if (config) {
+        this.configPath = packagePath;
+        return config;
+      }
+    } catch {
+    }
+    return null;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getConfigPath() {
+    return this.configPath;
+  }
+  mergeWithOptions(options) {
+    const base = this.config || {};
+    return {
+      ...base,
+      ...options,
+      discovery: {
+        ...base.discovery,
+        ...options.discovery
+      },
+      validation: {
+        ...base.validation,
+        ...options.validation
+      },
+      plugins: this.mergeArrays(base.plugins, options.plugins),
+      pluginDirs: this.mergeArrays(base.pluginDirs, options.pluginDirs),
+      aliases: {
+        ...base.aliases,
+        ...options.aliases
+      }
+    };
+  }
+  mergeArrays(arr1, arr2) {
+    if (!arr1 && !arr2) return void 0;
+    if (!arr1) return arr2;
+    if (!arr2) return arr1;
+    return Array.from(/* @__PURE__ */ new Set([...arr1, ...arr2]));
+  }
+  resolveAlias(name) {
+    if (this.config?.aliases && this.config.aliases[name]) {
+      return this.config.aliases[name];
+    }
+    return name;
+  }
+  getConfiguredPlugins() {
+    return this.config?.plugins || [];
+  }
+  getPluginDirectories() {
+    const dirs = this.config?.pluginDirs || [];
+    if (this.configPath) {
+      const configDir = path10.dirname(this.configPath);
+      return dirs.map((dir) => {
+        if (path10.isAbsolute(dir)) return dir;
+        return path10.resolve(configDir, dir);
+      });
+    }
+    return dirs.map((dir) => path10.resolve(process.cwd(), dir));
+  }
+  isAutoDiscoverEnabled() {
+    return this.config?.autoDiscover ?? false;
+  }
+  async saveConfig(config, filePath) {
+    const targetPath = filePath || this.configPath || path10.join(process.cwd(), ".json-to-office.config.json");
+    const content = JSON.stringify(config, null, 2);
+    await fs9.writeFile(targetPath, content, "utf-8");
+    this.config = config;
+    this.configPath = targetPath;
+  }
+  async createDefaultConfig(filePath) {
+    const defaultConfig2 = {
+      plugins: [],
+      pluginDirs: ["./plugins", "./custom-components"],
+      autoDiscover: false,
+      aliases: {},
+      theme: "minimal",
+      discovery: {
+        maxDepth: 5,
+        includeNodeModules: false
+      },
+      validation: {
+        strict: false,
+        allowUnknownFields: true
+      }
+    };
+    await this.saveConfig(defaultConfig2, filePath);
+  }
+  clearConfig() {
+    this.config = null;
+    this.configPath = null;
+  }
+};
+
+// src/config/loader.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { resolve as resolve10 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+
+// src/config/schema.ts
+import { Type } from "@sinclair/typebox";
+var ConfigSchema = Type.Object({
+  mode: Type.Union([Type.Literal("development"), Type.Literal("production")], {
+    default: "development"
+  }),
+  server: Type.Object({
+    port: Type.Number({ default: 3003, minimum: 0, maximum: 65535 }),
+    host: Type.String({ default: "localhost" }),
+    cors: Type.Optional(
+      Type.Object({
+        origin: Type.Union([Type.String(), Type.Array(Type.String())]),
+        credentials: Type.Boolean({ default: true })
+      })
+    )
+  }),
+  api: Type.Object({
+    basePath: Type.String({ default: "/api" }),
+    rateLimit: Type.Optional(
+      Type.Object({
+        windowMs: Type.Number({ default: 6e4 }),
+        max: Type.Number({ default: 100 })
+      })
+    ),
+    upload: Type.Object({
+      maxFileSize: Type.Number({ default: 10 * 1024 * 1024 }),
+      allowedMimeTypes: Type.Array(Type.String(), {
+        default: ["image/jpeg", "image/png", "image/gif", "image/svg+xml"]
+      })
+    })
+  }),
+  playground: Type.Object({
+    enabled: Type.Boolean({ default: true }),
+    root: Type.String({ default: "../../apps/web-react" }),
+    features: Type.Object({
+      livePreview: Type.Boolean({ default: true }),
+      templateLibrary: Type.Boolean({ default: true }),
+      componentBuilder: Type.Boolean({ default: false }),
+      collaboration: Type.Boolean({ default: false })
+    })
+  }),
+  development: Type.Object({
+    hmr: Type.Boolean({ default: true }),
+    hmrPort: Type.Optional(Type.Number()),
+    sourceMap: Type.Boolean({ default: true }),
+    verbose: Type.Boolean({ default: false })
+  }),
+  paths: Type.Object({
+    templates: Type.String({ default: "./templates" }),
+    modules: Type.String({ default: "./modules" }),
+    cache: Type.String({ default: "./.cache" })
+  })
+});
+
+// src/config/loader.ts
+import { Value } from "@sinclair/typebox/value";
+
+// src/config/defaults.ts
+var defaultConfig = {
+  mode: "development",
+  server: {
+    port: 3003,
+    host: "localhost",
+    cors: {
+      origin: "*",
+      credentials: true
+    }
+  },
+  api: {
+    basePath: "/api",
+    upload: {
+      maxFileSize: 10 * 1024 * 1024,
+      allowedMimeTypes: [
+        "image/jpeg",
+        "image/png",
+        "image/gif",
+        "image/svg+xml"
+      ]
+    }
+  },
+  playground: {
+    enabled: true,
+    root: "../../apps/web-react",
+    features: {
+      livePreview: true,
+      templateLibrary: true,
+      componentBuilder: false,
+      collaboration: false
+    }
+  },
+  development: {
+    hmr: true,
+    sourceMap: true,
+    verbose: false
+  },
+  paths: {
+    templates: "./templates",
+    modules: "./modules",
+    cache: "./.cache"
+  }
+};
+
+// src/config/loader.ts
+var CONFIG_FILES = [
+  "json-to-office.config.ts",
+  "json-to-office.config.js",
+  "json-to-office.config.mjs",
+  "json-to-office.config.json",
+  // Legacy support
+  "json-to-docx.config.ts",
+  "json-to-docx.config.js",
+  "json-to-docx.config.json",
+  "json-to-pptx.config.ts",
+  "json-to-pptx.config.js",
+  "json-to-pptx.config.json"
+];
+async function loadConfig(configPath) {
+  let userConfig = {};
+  const configFile = configPath || await findConfigFile();
+  if (configFile) {
+    try {
+      userConfig = await loadConfigFile(configFile);
+    } catch (error) {
+      console.warn(`Warning: Failed to load config file: ${error.message}`);
+    }
+  }
+  const config = deepMerge(defaultConfig, userConfig);
+  if (!Value.Check(ConfigSchema, config)) {
+    const errors = [...Value.Errors(ConfigSchema, config)];
+    console.warn("Warning: Invalid configuration detected:", errors);
+    return defaultConfig;
+  }
+  return config;
+}
+async function findConfigFile() {
+  const cwd = process.cwd();
+  for (const filename of CONFIG_FILES) {
+    const filepath = resolve10(cwd, filename);
+    if (existsSync3(filepath)) {
+      return filepath;
+    }
+  }
+  return null;
+}
+async function loadConfigFile(filepath) {
+  const ext = filepath.split(".").pop();
+  if (ext === "json") {
+    const content = await readFile4(filepath, "utf-8");
+    return JSON.parse(content);
+  }
+  const fileUrl = pathToFileURL2(filepath).href;
+  const module = await import(fileUrl);
+  return module.default || module;
+}
+function deepMerge(target, source) {
+  const output = { ...target };
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isObject(source[key])) {
+        if (!(key in target)) {
+          Object.assign(output, { [key]: source[key] });
+        } else {
+          output[key] = deepMerge(target[key], source[key]);
+        }
+      } else {
+        Object.assign(output, { [key]: source[key] });
+      }
+    });
+  }
+  return output;
+}
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+export {
+  DocxFormatAdapter,
+  GeneratorFactory,
+  JsonValidator,
+  PluginConfigService,
+  PluginDiscoveryService,
+  PluginLoader,
+  PluginMetadataExtractor,
+  PluginRegistry,
+  PluginResolver,
+  PptxFormatAdapter,
+  SchemaGenerator,
+  createAdapter,
+  loadConfig
+};
+//# sourceMappingURL=index.js.map