@bfra.me/doc-sync 0.1.0 → 0.1.1

package/lib/{chunk-DR6UG237.js → chunk-NC7YTZAL.js}

@@ -1,17 +1,25 @@
 import {
-  createHeadingPattern,
-  extractCodeBlocks,
-  findEmptyMarkdownLinks,
   generateMDXDocument,
-  hasComponent,
   mergeContent,
   validateMDXSyntax
-} from "./chunk-G5KKGJYO.js";
+} from "./chunk-LOB73H77.js";
 import {
   analyzePublicAPI,
   parsePackageComplete,
   parseReadmeFile
 } from "./chunk-6NKAJT2M.js";
+import {
+  createHeadingPattern,
+  extractCodeBlocks,
+  findEmptyMarkdownLinks,
+  hasComponent
+} from "./chunk-GZ2MP3VN.js";
+import {
+  createDocDebouncer,
+  createDocWatcher,
+  determineRegenerationScope,
+  groupChangesByPackage
+} from "./chunk-45NROJIG.js";
 
 // src/orchestrator/package-scanner.ts
 import fs from "fs/promises";
@@ -197,318 +205,6 @@ function getPackageScope(packageName) {
   return void 0;
 }
 
-// src/watcher/file-watcher.ts
-import path2 from "path";
-import process from "process";
-import { createFileWatcher as createBaseWatcher } from "@bfra.me/es/watcher";
-var DEFAULT_WATCH_PATTERNS = [
-  "packages/*/README.md",
-  "packages/*/readme.md",
-  "packages/*/package.json",
-  "packages/*/src/**/*.ts",
-  "packages/*/src/**/*.tsx"
-];
-var DEFAULT_IGNORE_PATTERNS = [
-  "**/node_modules/**",
-  "**/lib/**",
-  "**/dist/**",
-  "**/.git/**",
-  "**/coverage/**",
-  "**/*.test.ts",
-  "**/*.spec.ts",
-  "**/__tests__/**",
-  "**/__mocks__/**"
-];
-function extractPackageName(filePath, root) {
-  const relativePath = path2.relative(root, filePath);
-  const parts = relativePath.split(path2.sep);
-  if (parts[0] === "packages" && parts.length > 1) {
-    return parts[1];
-  }
-  return void 0;
-}
-function createDocWatcher(options = {}) {
-  const {
-    rootDir = process.cwd(),
-    debounceMs = 300,
-    additionalIgnore = [],
-    usePolling = false
-  } = options;
-  const watchPaths = DEFAULT_WATCH_PATTERNS.map((pattern) => path2.join(rootDir, pattern));
-  const ignoredPatterns = [...DEFAULT_IGNORE_PATTERNS, ...additionalIgnore];
-  const watcherOptions = {
-    debounceMs,
-    ignored: ignoredPatterns,
-    usePolling
-  };
-  const baseWatcher = createBaseWatcher(watchPaths, watcherOptions);
-  const handlers = /* @__PURE__ */ new Set();
-  function transformToDocEvents(changes) {
-    return changes.map((change) => ({
-      type: change.type,
-      path: change.path,
-      packageName: extractPackageName(change.path, rootDir),
-      timestamp: new Date(change.timestamp)
-    }));
-  }
-  return {
-    async start() {
-      baseWatcher.on("change", (event) => {
-        const docEvents = transformToDocEvents(event.changes);
-        for (const handler of handlers) {
-          Promise.resolve(handler(docEvents)).catch((error) => {
-            console.error("[doc-sync] Error in change handler:", error);
-          });
-        }
-      });
-      await baseWatcher.start();
-    },
-    async close() {
-      await baseWatcher.close();
-      handlers.clear();
-    },
-    onChanges(handler) {
-      handlers.add(handler);
-      return () => {
-        handlers.delete(handler);
-      };
-    },
-    getWatchedPaths() {
-      return watchPaths;
-    }
-  };
-}
-function categorizeFile(filePath) {
-  const basename = path2.basename(filePath).toLowerCase();
-  if (basename === "readme.md" || basename === "readme") {
-    return "readme";
-  }
-  if (basename === "package.json") {
-    return "package-json";
-  }
-  const ext = path2.extname(filePath).toLowerCase();
-  if (ext === ".ts" || ext === ".tsx") {
-    return "source";
-  }
-  return "unknown";
-}
-function groupChangesByPackage(events) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const pkg = event.packageName ?? "__unknown__";
-    const existing = grouped.get(pkg);
-    if (existing === void 0) {
-      grouped.set(pkg, [event]);
-    } else {
-      existing.push(event);
-    }
-  }
-  return grouped;
-}
-function filterDocumentationChanges(events) {
-  return events.filter((event) => {
-    const category = categorizeFile(event.path);
-    return category !== "unknown";
-  });
-}
-
-// src/watcher/change-detector.ts
-import { createChangeDetector as createBaseDetector } from "@bfra.me/es/watcher";
-function createDocChangeDetector(options = {}) {
-  const baseDetector = createBaseDetector({ algorithm: options.algorithm });
-  const packageFiles = /* @__PURE__ */ new Map();
-  return {
-    async hasChanged(filePath) {
-      return baseDetector.hasChanged(filePath);
-    },
-    async record(filePath) {
-      await baseDetector.record(filePath);
-    },
-    async recordPackage(pkg, files) {
-      const fileSet = new Set(files);
-      packageFiles.set(pkg.name, fileSet);
-      await Promise.all(files.map(async (file) => baseDetector.record(file)));
-    },
-    clear(filePath) {
-      baseDetector.clear(filePath);
-      for (const fileSet of packageFiles.values()) {
-        fileSet.delete(filePath);
-      }
-    },
-    clearAll() {
-      baseDetector.clearAll();
-      packageFiles.clear();
-    },
-    async analyzeChanges(events) {
-      const packageChanges = /* @__PURE__ */ new Map();
-      for (const event of events) {
-        const packageName = event.packageName ?? "__unknown__";
-        const category = categorizeFile(event.path);
-        let analysis = packageChanges.get(packageName);
-        if (analysis === void 0) {
-          analysis = { categories: /* @__PURE__ */ new Set(), files: [] };
-          packageChanges.set(packageName, analysis);
-        }
-        if (category !== "unknown") {
-          analysis.categories.add(category);
-        }
-        analysis.files.push(event.path);
-      }
-      const results = [];
-      for (const [packageName, analysis] of packageChanges) {
-        const changedCategories = [...analysis.categories];
-        const needsRegeneration = changedCategories.includes("readme") || changedCategories.includes("package-json") || changedCategories.includes("source");
-        results.push({
-          packageName,
-          needsRegeneration,
-          changedCategories,
-          changedFiles: analysis.files
-        });
-      }
-      return results;
-    }
-  };
-}
-function determineRegenerationScope(changedCategories) {
-  const hasReadme = changedCategories.includes("readme");
-  const hasSource = changedCategories.includes("source");
-  const hasPackageJson = changedCategories.includes("package-json");
-  if (hasReadme && hasSource) {
-    return "full";
-  }
-  if (hasSource) {
-    return "api-only";
-  }
-  if (hasReadme) {
-    return "readme-only";
-  }
-  if (hasPackageJson) {
-    return "metadata-only";
-  }
-  return "none";
-}
-async function hasAnyFileChanged(detector, files) {
-  const results = await Promise.all(files.map(async (file) => detector.hasChanged(file)));
-  return results.some((changed) => changed);
-}
-
-// src/watcher/debouncer.ts
-import { createDebouncer as createBaseDebouncer } from "@bfra.me/es/watcher";
-function createDocDebouncer(handler, options = {}) {
-  const { debounceMs = 300, maxWaitMs = 5e3 } = options;
-  let pendingEvents = [];
-  let maxWaitTimeout;
-  function processEvents(events) {
-    if (maxWaitTimeout !== void 0) {
-      clearTimeout(maxWaitTimeout);
-      maxWaitTimeout = void 0;
-    }
-    const deduplicated = deduplicateEvents(events);
-    if (deduplicated.length > 0) {
-      Promise.resolve(handler(deduplicated)).catch((error) => {
-        console.error("[doc-sync] Error in batch handler:", error);
-      });
-    }
-  }
-  const baseDebouncer = createBaseDebouncer((events) => {
-    processEvents(events);
-    pendingEvents = [];
-  }, debounceMs);
-  function startMaxWaitTimer() {
-    if (maxWaitTimeout === void 0) {
-      maxWaitTimeout = setTimeout(() => {
-        baseDebouncer.flush();
-      }, maxWaitMs);
-    }
-  }
-  return {
-    add(event) {
-      pendingEvents.push(event);
-      startMaxWaitTimer();
-      baseDebouncer.add(event);
-    },
-    addAll(events) {
-      for (const event of events) {
-        pendingEvents.push(event);
-        baseDebouncer.add(event);
-      }
-      if (events.length > 0) {
-        startMaxWaitTimer();
-      }
-    },
-    flush() {
-      if (maxWaitTimeout !== void 0) {
-        clearTimeout(maxWaitTimeout);
-        maxWaitTimeout = void 0;
-      }
-      baseDebouncer.flush();
-    },
-    cancel() {
-      if (maxWaitTimeout !== void 0) {
-        clearTimeout(maxWaitTimeout);
-        maxWaitTimeout = void 0;
-      }
-      pendingEvents = [];
-      baseDebouncer.cancel();
-    },
-    getPendingCount() {
-      return pendingEvents.length;
-    }
-  };
-}
-function deduplicateEvents(events) {
-  const latestByPath = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const existing = latestByPath.get(event.path);
-    if (existing === void 0 || event.timestamp > existing.timestamp) {
-      latestByPath.set(event.path, event);
-    }
-  }
-  return [...latestByPath.values()];
-}
-function consolidateEvents(events) {
-  const byPath = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const existing = byPath.get(event.path);
-    if (existing === void 0) {
-      byPath.set(event.path, [event]);
-    } else {
-      existing.push(event);
-    }
-  }
-  const consolidated = [];
-  for (const [, pathEvents] of byPath) {
-    const firstEvent = pathEvents[0];
-    if (firstEvent === void 0) {
-      continue;
-    }
-    if (pathEvents.length === 1) {
-      consolidated.push(firstEvent);
-      continue;
-    }
-    pathEvents.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-    const first = pathEvents[0];
-    const last = pathEvents.at(-1);
-    if (first === void 0 || last === void 0) {
-      continue;
-    }
-    if (first.type === "add" && last.type === "unlink") {
-      continue;
-    }
-    if (first.type === "unlink" && last.type === "add") {
-      consolidated.push({
-        type: "change",
-        path: last.path,
-        packageName: last.packageName,
-        timestamp: last.timestamp
-      });
-      continue;
-    }
-    consolidated.push(last);
-  }
-  return consolidated;
-}
-
 // src/orchestrator/validation-pipeline.ts
 import { err as err2, ok as ok2 } from "@bfra.me/es/result";
 var DEFAULT_OPTIONS2 = {
@@ -722,7 +418,7 @@ function validateContentString(content, options) {
 
 // src/orchestrator/sync-orchestrator.ts
 import fs2 from "fs/promises";
-import path3 from "path";
+import path2 from "path";
 import { err as err3, ok as ok3 } from "@bfra.me/es/result";
 function createSyncOrchestrator(options) {
   const { config, dryRun = false, verbose = false, onProgress, onError } = options;
@@ -943,7 +639,7 @@ function createSyncOrchestrator(options) {
 }
 function getOutputPath(packageName, outputDir) {
   const slug = createSlug(getUnscopedName2(packageName));
-  return path3.join(outputDir, `${slug}.mdx`);
+  return path2.join(outputDir, `${slug}.mdx`);
 }
 function createSlug(name) {
   return name.toLowerCase().replaceAll(/[^a-z0-9-]/g, "-");
@@ -958,7 +654,7 @@ function getUnscopedName2(packageName) {
   return packageName;
 }
 async function writeFile(filePath, content) {
-  const dir = path3.dirname(filePath);
+  const dir = path2.dirname(filePath);
   await fs2.mkdir(dir, { recursive: true });
   await fs2.writeFile(filePath, content, "utf-8");
 }
@@ -992,15 +688,15 @@ function isNodeError(error) {
   return error instanceof Error && "code" in error;
 }
 function categorizeFileChange(filePath) {
-  const basename = path3.basename(filePath).toLowerCase();
+  const basename = path2.basename(filePath).toLowerCase();
   if (basename === "readme.md" || basename === "readme") return "readme";
   if (basename === "package.json") return "package-json";
   if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) return "source";
   return "unknown";
 }
 function isValidFilePath(filePath, rootDir) {
-  const resolvedPath = path3.resolve(filePath);
-  const resolvedRoot = path3.resolve(rootDir);
+  const resolvedPath = path2.resolve(filePath);
+  const resolvedRoot = path2.resolve(rootDir);
   return resolvedPath.startsWith(resolvedRoot);
 }
 
@@ -1008,20 +704,10 @@ export {
   createPackageScanner,
   filterPackagesByPattern,
   groupPackagesByScope,
-  createDocWatcher,
-  categorizeFile,
-  groupChangesByPackage,
-  filterDocumentationChanges,
-  createDocChangeDetector,
-  determineRegenerationScope,
-  hasAnyFileChanged,
-  createDocDebouncer,
-  deduplicateEvents,
-  consolidateEvents,
   createValidationPipeline,
   validateDocument,
   validateContentString,
   createSyncOrchestrator,
   isValidFilePath
 };
-//# sourceMappingURL=chunk-DR6UG237.js.map
+//# sourceMappingURL=chunk-NC7YTZAL.js.map

package/lib/chunk-SQSYXPIF.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-SQSYXPIF.js.map

package/lib/cli/index.js

@@ -3,15 +3,17 @@ import {
   createPackageScanner,
   createSyncOrchestrator,
   createValidationPipeline
-} from "../chunk-DR6UG237.js";
+} from "../chunk-NC7YTZAL.js";
 import {
   generateMDXDocument,
   mergeContent
-} from "../chunk-G5KKGJYO.js";
+} from "../chunk-LOB73H77.js";
 import "../chunk-ROLA7SBB.js";
 import {
   getUnscopedName
 } from "../chunk-6NKAJT2M.js";
+import "../chunk-GZ2MP3VN.js";
+import "../chunk-45NROJIG.js";
 
 // src/cli/index.ts
 import process4 from "process";

package/lib/generators/index.d.ts

@@ -160,9 +160,7 @@ declare function generateMDXDocument(packageInfo: PackageInfo, readme: ReadmeCon
 declare function sanitizeContent(content: string): string;
 /**
  * Sanitizes content within MDX while preserving JSX components
- * Only escapes content that appears to be user-provided text
- * Now includes sanitization of JSX component attributes to prevent XSS
- * Uses safe, non-backtracking parsing to prevent ReDoS
+ * Sanitizes JSX component attributes to prevent XSS while leaving closing tags unchanged
  */
 declare function sanitizeTextContent(content: string): string;
 declare function validateMDXSyntax(mdx: string): Result<true, SyncError>;

package/lib/generators/index.js

@@ -34,8 +34,9 @@ import {
   validateMarkerPairing,
   wrapAutoSection,
   wrapManualSection
-} from "../chunk-G5KKGJYO.js";
+} from "../chunk-LOB73H77.js";
 import "../chunk-ROLA7SBB.js";
+import "../chunk-GZ2MP3VN.js";
 export {
   cleanCodeExample,
   createBadge,

package/lib/index.d.ts

@@ -1,141 +1,9 @@
 export { CodeExampleOptions, ComponentMapperConfig, ContentSection, MDXGeneratorOptions, MergeOptions, MergeResult, SectionMapper, cleanCodeExample, createBadge, createCard, createCardGrid, createDiffSummary, createTabs, detectLanguage, extractAutoSections, extractManualSections, formatCodeBlock, formatCodeExamples, formatFunctionExamples, formatGroupedExamples, formatTypeExamples, formatUsageExample, generateAPICompact, generateAPIReference, generateCategoryReference, generateFrontmatter, generateInstallTabs, generateMDXDocument, groupExamplesByCategory, hasAutoContent, hasManualContent, mapToStarlightComponents, mergeContent, parseFrontmatter, sanitizeContent, sanitizeTextContent, stringifyFrontmatter, stripSentinelMarkers, validateMDXSyntax, validateMarkerPairing, wrapAutoSection, wrapManualSection } from './generators/index.js';
-import { Result } from '@bfra.me/es/result';
-import { PackageInfo, ReadmeContent, PackageAPI, SyncError, FileChangeEvent, DocConfig, SyncSummary, MDXDocument } from './types.js';
-export { CLIOptions, DocConfigSource, ExportedFunction, ExportedType, FunctionParameter, InferSchema, JSDocInfo, JSDocParam, JSDocTag, MDXFrontmatter, ParseError, ParseErrorCode, ParseResult, ReExport, ReadmeSection, SENTINEL_MARKERS, SyncErrorCode, SyncInfo, SyncResult } from './types.js';
+export { PackageScannerOptions, ScanResult, ScannedPackage, SyncOrchestrator, SyncOrchestratorOptions, ValidationError, ValidationPipelineOptions, ValidationResult, ValidationWarning, createPackageScanner, createSyncOrchestrator, createValidationPipeline, filterPackagesByPattern, groupPackagesByScope, isValidFilePath, validateContentString, validateDocument } from './orchestrator/index.js';
+export { ExportAnalyzerOptions, JSDocableDeclaration, PackageInfoOptions, PackageJsonSchema, PublicAPIAnalysis, ReadmeParserOptions, ResolvedExport, TypeScriptParserOptions, analyzePublicAPI, analyzeTypeScriptContent, analyzeTypeScriptFile, assertPackageAPI, assertPackageInfo, assertParseError, buildDocSlug, createProject, extractDocsConfig, extractExportedFunctions, extractExportedTypes, extractJSDocInfo, extractPackageAPI, extractReExports, findEntryPoint, findExportedSymbols, findReadmePath, findSection, flattenSections, getExportedSymbolInfo, getExportsByKind, getPackageScope, getSectionsByLevel, getTableOfContents, getUnscopedName, hasJSDoc, isDocConfigSource, isExportedFunction, isExportedType, isJSDocInfo, isJSDocParam, isJSDocTag, isMDXFrontmatter, isPackageAPI, isPackageInfo, isParseError, isReExport, isReadmeContent, isReadmeSection, isSafeContent, isSafeFilePath, isSymbolExported, isSyncError, isValidHeadingLevel, isValidPackageName, isValidSemver, parseJSDoc, parsePackageComplete, parsePackageJson, parsePackageJsonContent, parseReadme, parseReadmeFile, parseSourceContent, parseSourceFile } from './parsers/index.js';
+export { CLIOptions, DocConfig, DocConfigSource, ExportedFunction, ExportedType, FileChangeEvent, FunctionParameter, InferSchema, JSDocInfo, JSDocParam, JSDocTag, MDXDocument, MDXFrontmatter, PackageAPI, PackageInfo, ParseError, ParseErrorCode, ParseResult, ReExport, ReadmeContent, ReadmeSection, SENTINEL_MARKERS, SyncError, SyncErrorCode, SyncInfo, SyncResult, SyncSummary } from './types.js';
+export { createHeadingPattern, extractCodeBlocks, findEmptyMarkdownLinks, hasComponent, parseJSXAttributes, parseJSXTags, sanitizeAttribute, sanitizeForMDX, sanitizeJSXTag } from './utils/index.js';
+export { BatchChangeHandler, DocChangeDetector, DocChangeDetectorOptions, DocChangeHandler, DocDebouncer, DocDebouncerOptions, DocFileWatcher, DocWatcherOptions, FileCategory, PackageChangeAnalysis, RegenerationScope, categorizeFile, consolidateEvents, createDocChangeDetector, createDocDebouncer, createDocWatcher, deduplicateEvents, determineRegenerationScope, filterDocumentationChanges, groupChangesByPackage, hasAnyFileChanged } from './watcher/index.js';
+import '@bfra.me/es/result';
+import 'ts-morph';
 import 'zod';
-
-interface PackageScannerOptions {
-    readonly rootDir: string;
-    readonly includePatterns?: readonly string[];
-    readonly excludePackages?: readonly string[];
-    readonly parseSourceFiles?: boolean;
-    readonly parseReadme?: boolean;
-}
-interface ScannedPackage {
-    readonly info: PackageInfo;
-    readonly readme?: ReadmeContent;
-    readonly api?: PackageAPI;
-    readonly sourceFiles: readonly string[];
-    readonly needsDocumentation: boolean;
-    readonly existingDocPath?: string;
-}
-interface ScanResult {
-    readonly packages: readonly ScannedPackage[];
-    readonly packagesNeedingDocs: readonly ScannedPackage[];
-    readonly errors: readonly SyncError[];
-    readonly durationMs: number;
-}
-declare function createPackageScanner(options: PackageScannerOptions): {
-    readonly scan: () => Promise<ScanResult>;
-    readonly scanPackage: (packagePath: string) => Promise<Result<ScannedPackage, SyncError>>;
-};
-declare function filterPackagesByPattern(packages: readonly ScannedPackage[], pattern: string): ScannedPackage[];
-declare function groupPackagesByScope(packages: readonly ScannedPackage[]): Map<string, ScannedPackage[]>;
-
-interface DocWatcherOptions {
-    readonly rootDir?: string;
-    readonly debounceMs?: number;
-    readonly additionalIgnore?: readonly string[];
-    readonly usePolling?: boolean;
-}
-type DocChangeHandler = (events: readonly FileChangeEvent[]) => void | Promise<void>;
-interface DocFileWatcher {
-    readonly start: () => Promise<void>;
-    readonly close: () => Promise<void>;
-    readonly onChanges: (handler: DocChangeHandler) => () => void;
-    readonly getWatchedPaths: () => readonly string[];
-}
-declare function createDocWatcher(options?: DocWatcherOptions): DocFileWatcher;
-type FileCategory = 'readme' | 'source' | 'package-json' | 'unknown';
-declare function categorizeFile(filePath: string): FileCategory;
-declare function groupChangesByPackage(events: readonly FileChangeEvent[]): Map<string, FileChangeEvent[]>;
-declare function filterDocumentationChanges(events: readonly FileChangeEvent[]): FileChangeEvent[];
-
-interface DocChangeDetectorOptions {
-    readonly algorithm?: 'sha256' | 'md5';
-}
-interface PackageChangeAnalysis {
-    readonly packageName: string;
-    readonly needsRegeneration: boolean;
-    readonly changedCategories: readonly FileCategory[];
-    readonly changedFiles: readonly string[];
-}
-interface DocChangeDetector {
-    readonly hasChanged: (filePath: string) => Promise<boolean>;
-    readonly record: (filePath: string) => Promise<void>;
-    readonly recordPackage: (pkg: PackageInfo, files: readonly string[]) => Promise<void>;
-    readonly clear: (filePath: string) => void;
-    readonly clearAll: () => void;
-    readonly analyzeChanges: (events: readonly FileChangeEvent[]) => Promise<PackageChangeAnalysis[]>;
-}
-declare function createDocChangeDetector(options?: DocChangeDetectorOptions): DocChangeDetector;
-type RegenerationScope = 'full' | 'api-only' | 'readme-only' | 'metadata-only' | 'none';
-declare function determineRegenerationScope(changedCategories: readonly FileCategory[]): RegenerationScope;
-declare function hasAnyFileChanged(detector: DocChangeDetector, files: readonly string[]): Promise<boolean>;
-
-interface DocDebouncerOptions {
-    readonly debounceMs?: number;
-    readonly maxWaitMs?: number;
-}
-type BatchChangeHandler = (events: readonly FileChangeEvent[]) => void | Promise<void>;
-interface DocDebouncer {
-    readonly add: (event: FileChangeEvent) => void;
-    readonly addAll: (events: readonly FileChangeEvent[]) => void;
-    readonly flush: () => void;
-    readonly cancel: () => void;
-    readonly getPendingCount: () => number;
-}
-declare function createDocDebouncer(handler: BatchChangeHandler, options?: DocDebouncerOptions): DocDebouncer;
-declare function deduplicateEvents(events: readonly FileChangeEvent[]): FileChangeEvent[];
-declare function consolidateEvents(events: readonly FileChangeEvent[]): FileChangeEvent[];
-
-interface SyncOrchestratorOptions {
-    readonly config: DocConfig;
-    readonly dryRun?: boolean;
-    readonly verbose?: boolean;
-    readonly onProgress?: (message: string) => void;
-    readonly onError?: (error: SyncError) => void;
-}
-interface SyncOrchestrator {
-    readonly syncAll: () => Promise<SyncSummary>;
-    readonly syncPackages: (packageNames: readonly string[]) => Promise<SyncSummary>;
-    readonly handleChanges: (events: readonly FileChangeEvent[]) => Promise<SyncSummary>;
-    readonly startWatching: () => Promise<void>;
-    readonly stopWatching: () => Promise<void>;
-    readonly isWatching: () => boolean;
-}
-declare function createSyncOrchestrator(options: SyncOrchestratorOptions): SyncOrchestrator;
-/** Prevents directory traversal attacks (SEC-002) */
-declare function isValidFilePath(filePath: string, rootDir: string): boolean;
-
-interface ValidationResult {
-    readonly valid: boolean;
-    readonly errors: readonly ValidationError[];
-    readonly warnings: readonly ValidationWarning[];
-}
-interface ValidationError {
-    readonly type: 'syntax' | 'frontmatter' | 'component' | 'content';
-    readonly message: string;
-    readonly line?: number;
-    readonly column?: number;
-}
-interface ValidationWarning {
-    readonly type: 'deprecation' | 'recommendation' | 'compatibility';
-    readonly message: string;
-    readonly line?: number;
-}
-interface ValidationPipelineOptions {
-    readonly validateFrontmatter?: boolean;
-    readonly validateComponents?: boolean;
-    readonly validateContent?: boolean;
-    readonly strict?: boolean;
-}
-declare function createValidationPipeline(options?: ValidationPipelineOptions): {
-    readonly validate: (doc: MDXDocument) => ValidationResult;
-    readonly validateContent: (content: string) => ValidationResult;
-    readonly validateMultiple: (docs: readonly MDXDocument[]) => Result<Map<string, ValidationResult>, SyncError>;
-};
-declare function validateDocument(doc: MDXDocument, options?: ValidationPipelineOptions): Result<MDXDocument, SyncError>;
-declare function validateContentString(content: string, options?: ValidationPipelineOptions): Result<string, SyncError>;
-
-export { type BatchChangeHandler, type DocChangeDetector, type DocChangeDetectorOptions, type DocChangeHandler, DocConfig, type DocDebouncer, type DocDebouncerOptions, type DocFileWatcher, type DocWatcherOptions, type FileCategory, FileChangeEvent, MDXDocument, PackageAPI, type PackageChangeAnalysis, PackageInfo, type PackageScannerOptions, ReadmeContent, type RegenerationScope, type ScanResult, type ScannedPackage, SyncError, type SyncOrchestrator, type SyncOrchestratorOptions, SyncSummary, type ValidationError, type ValidationPipelineOptions, type ValidationResult, type ValidationWarning, categorizeFile, consolidateEvents, createDocChangeDetector, createDocDebouncer, createDocWatcher, createPackageScanner, createSyncOrchestrator, createValidationPipeline, deduplicateEvents, determineRegenerationScope, filterDocumentationChanges, filterPackagesByPattern, groupChangesByPackage, groupPackagesByScope, hasAnyFileChanged, isValidFilePath, validateContentString, validateDocument };