folderblog 0.0.1 → 0.0.2

package/dist/config-DFr-htlO.d.cts

@@ -0,0 +1,887 @@
+/**
+ * Issue tracking types for @repo-md/processor-core
+ */
+type IssueSeverity = 'error' | 'warning' | 'info';
+type IssueCategory = 'broken-link' | 'missing-media' | 'media-processing' | 'slug-conflict' | 'mermaid-error' | 'frontmatter-error' | 'parse-error' | 'file-access' | 'embedding-error' | 'database-error' | 'plugin-error' | 'configuration' | 'other';
+type IssueModule = 'markdown-parser' | 'image-processor' | 'embed-mermaid' | 'embed-media' | 'link-resolver' | 'slug-generator' | 'frontmatter-parser' | 'file-system' | 'config-validator' | 'post-processor' | 'text-embeddings' | 'image-embeddings' | 'similarity' | 'database' | 'plugin-manager' | 'other';
+/**
+ * Base interface for all processing issues
+ */
+interface ProcessingIssue {
+    readonly severity: IssueSeverity;
+    readonly category: IssueCategory;
+    readonly module: IssueModule;
+    readonly message: string;
+    readonly filePath?: string;
+    readonly lineNumber?: number;
+    readonly columnNumber?: number;
+    readonly context?: Readonly<Record<string, unknown>>;
+    readonly timestamp: string;
+}
+/**
+ * Broken link issue
+ */
+interface BrokenLinkIssue extends ProcessingIssue {
+    readonly category: 'broken-link';
+    readonly module: 'link-resolver';
+    readonly context: {
+        readonly linkText: string;
+        readonly linkTarget: string;
+        readonly linkType: 'wiki' | 'markdown' | 'frontmatter';
+        readonly suggestions?: readonly string[];
+    };
+}
+/**
+ * Missing media issue
+ */
+interface MissingMediaIssue extends ProcessingIssue {
+    readonly category: 'missing-media';
+    readonly module: 'embed-media' | 'image-processor';
+    readonly context: {
+        readonly mediaPath: string;
+        readonly referencedFrom: 'content' | 'frontmatter' | 'embed';
+        readonly originalReference?: string;
+    };
+}
+/**
+ * Media processing issue
+ */
+interface MediaProcessingIssue extends ProcessingIssue {
+    readonly category: 'media-processing';
+    readonly module: 'image-processor';
+    readonly context: {
+        readonly mediaPath: string;
+        readonly operation: 'read' | 'optimize' | 'resize' | 'hash' | 'copy';
+        readonly errorMessage: string;
+        readonly errorCode?: string;
+    };
+}
+/**
+ * Slug conflict issue
+ */
+interface SlugConflictIssue extends ProcessingIssue {
+    readonly category: 'slug-conflict';
+    readonly module: 'slug-generator';
+    readonly context: {
+        readonly originalSlug: string;
+        readonly finalSlug: string;
+        readonly conflictingFiles: readonly string[];
+    };
+}
+/**
+ * Mermaid error issue
+ */
+interface MermaidErrorIssue extends ProcessingIssue {
+    readonly category: 'mermaid-error';
+    readonly module: 'embed-mermaid';
+    readonly context: {
+        readonly errorType: 'plugin-load' | 'render-fail' | 'missing-deps';
+        readonly diagramContent?: string;
+        readonly fallback: string;
+    };
+}
+/**
+ * Embedding error issue
+ */
+interface EmbeddingErrorIssue extends ProcessingIssue {
+    readonly category: 'embedding-error';
+    readonly module: 'text-embeddings' | 'image-embeddings';
+    readonly context: {
+        readonly embeddingType: 'text' | 'image';
+        readonly operation: 'initialize' | 'embed' | 'batch';
+        readonly errorMessage: string;
+    };
+}
+/**
+ * Plugin error issue
+ */
+interface PluginErrorIssue extends ProcessingIssue {
+    readonly category: 'plugin-error';
+    readonly module: 'plugin-manager';
+    readonly context: {
+        readonly pluginName: string;
+        readonly operation: 'initialize' | 'process' | 'dispose';
+        readonly errorMessage: string;
+    };
+}
+declare const isBrokenLinkIssue: (issue: ProcessingIssue) => issue is BrokenLinkIssue;
+declare const isMissingMediaIssue: (issue: ProcessingIssue) => issue is MissingMediaIssue;
+declare const isMediaProcessingIssue: (issue: ProcessingIssue) => issue is MediaProcessingIssue;
+declare const isSlugConflictIssue: (issue: ProcessingIssue) => issue is SlugConflictIssue;
+declare const isMermaidErrorIssue: (issue: ProcessingIssue) => issue is MermaidErrorIssue;
+declare const isEmbeddingErrorIssue: (issue: ProcessingIssue) => issue is EmbeddingErrorIssue;
+declare const isPluginErrorIssue: (issue: ProcessingIssue) => issue is PluginErrorIssue;
+interface IssueSummary {
+    readonly totalIssues: number;
+    readonly errorCount: number;
+    readonly warningCount: number;
+    readonly infoCount: number;
+    readonly filesAffected: number;
+    readonly categoryCounts: Readonly<Record<IssueCategory, number>>;
+    readonly moduleCounts: Readonly<Record<IssueModule, number>>;
+}
+interface IssueReport {
+    readonly issues: readonly ProcessingIssue[];
+    readonly summary: IssueSummary;
+    readonly metadata: {
+        readonly processStartTime: string;
+        readonly processEndTime: string;
+        readonly processorVersion?: string;
+    };
+}
+interface IssueFilterOptions {
+    readonly severity?: IssueSeverity | readonly IssueSeverity[];
+    readonly category?: IssueCategory | readonly IssueCategory[];
+    readonly module?: IssueModule | readonly IssueModule[];
+    readonly filePath?: string | readonly string[];
+}
+
+/**
+ * Issue Collector Service
+ *
+ * Functional service for collecting and managing processing issues.
+ * Uses immutable patterns - returns new state rather than mutating.
+ */
+
+interface IssueCollectorState {
+    readonly issues: readonly ProcessingIssue[];
+    readonly startTime: string;
+}
+/**
+ * Service for collecting and managing processing issues.
+ * Provides both mutable (class-based) and functional interfaces.
+ */
+declare class IssueCollector {
+    private issues;
+    private readonly startTime;
+    constructor();
+    /**
+     * Add a generic issue
+     */
+    addIssue(issue: Omit<ProcessingIssue, 'timestamp'>): void;
+    /**
+     * Add a broken link issue
+     */
+    addBrokenLink(params: {
+        filePath: string;
+        lineNumber?: number;
+        linkText: string;
+        linkTarget: string;
+        linkType: 'wiki' | 'markdown' | 'frontmatter';
+        suggestions?: readonly string[];
+    }): void;
+    /**
+     * Add a missing media issue
+     */
+    addMissingMedia(params: {
+        filePath: string;
+        lineNumber?: number;
+        mediaPath: string;
+        referencedFrom: 'content' | 'frontmatter' | 'embed';
+        originalReference?: string;
+        module?: 'embed-media' | 'image-processor';
+    }): void;
+    /**
+     * Add a media processing error
+     */
+    addMediaProcessingError(params: {
+        filePath: string;
+        mediaPath: string;
+        operation: 'read' | 'optimize' | 'resize' | 'hash' | 'copy';
+        errorMessage: string;
+        errorCode?: string;
+    }): void;
+    /**
+     * Add a slug conflict warning
+     */
+    addSlugConflict(params: {
+        filePath: string;
+        originalSlug: string;
+        finalSlug: string;
+        conflictingFiles: readonly string[];
+    }): void;
+    /**
+     * Add a mermaid error
+     */
+    addMermaidError(params: {
+        filePath: string;
+        lineNumber?: number;
+        errorType: 'plugin-load' | 'render-fail' | 'missing-deps';
+        message: string;
+        diagramContent?: string;
+        fallback: string;
+    }): void;
+    /**
+     * Add an embedding error
+     */
+    addEmbeddingError(params: {
+        filePath?: string;
+        embeddingType: 'text' | 'image';
+        operation: 'initialize' | 'embed' | 'batch';
+        errorMessage: string;
+    }): void;
+    /**
+     * Add a plugin error
+     */
+    addPluginError(params: {
+        pluginName: string;
+        operation: 'initialize' | 'process' | 'dispose';
+        errorMessage: string;
+    }): void;
+    /**
+     * Get all issues
+     */
+    getIssues(): readonly ProcessingIssue[];
+    /**
+     * Filter issues
+     */
+    filterIssues(options: IssueFilterOptions): readonly ProcessingIssue[];
+    /**
+     * Get issue count by severity
+     */
+    getCountBySeverity(severity: IssueSeverity): number;
+    /**
+     * Check if there are any errors
+     */
+    hasErrors(): boolean;
+    /**
+     * Get summary string for console output
+     */
+    getSummaryString(): string;
+    /**
+     * Generate the final report
+     */
+    generateReport(): IssueReport;
+    /**
+     * Clear all issues (for testing)
+     */
+    clear(): void;
+}
+/**
+ * Filter issues based on criteria
+ */
+declare const filterIssues: (issues: readonly ProcessingIssue[], options: IssueFilterOptions) => readonly ProcessingIssue[];
+/**
+ * Calculate issue summary
+ */
+declare const calculateSummary: (issues: readonly ProcessingIssue[]) => IssueSummary;
+/**
+ * Generate issue report
+ */
+declare const generateIssueReport: (issues: readonly ProcessingIssue[], startTime: string, endTime: string) => IssueReport;
+
+/**
+ * Cache types for @repo-md/processor-core
+ *
+ * These types support incremental builds by allowing the processor
+ * to skip re-processing files that haven't changed.
+ */
+
+/**
+ * Cached metadata for a previously processed media file.
+ * Contains all information needed to skip image processing
+ * while still generating correct HTML output with dimensions.
+ */
+interface CachedMediaMetadata {
+    /** Original image width */
+    readonly width: number;
+    /** Original image height */
+    readonly height: number;
+    /** Output format (webp, avif, jpeg, png) */
+    readonly format: string;
+    /** Output file size in bytes */
+    readonly size: number;
+    /** Original file size in bytes */
+    readonly originalSize?: number;
+    /** Output file path relative to media output dir */
+    readonly outputPath: string;
+    /** Responsive size variants */
+    readonly sizes: readonly CachedMediaSizeVariant[];
+}
+/**
+ * Cached size variant for responsive images
+ */
+interface CachedMediaSizeVariant {
+    /** Size suffix (xs, sm, md, lg, xl) */
+    readonly suffix: string;
+    /** Output file path relative to media output dir */
+    readonly outputPath: string;
+    /** Width of this variant */
+    readonly width: number;
+    /** Height of this variant */
+    readonly height: number;
+    /** File size in bytes */
+    readonly size: number;
+}
+/**
+ * Cache context passed to the processor for incremental builds.
+ * All caches are keyed by content hash (SHA-256).
+ */
+interface CacheContext {
+    /**
+     * Cached media metadata keyed by content hash.
+     * When a media file's hash matches a cached entry, processing can be skipped
+     * and the cached metadata used for HTML rendering (dimensions, paths).
+     */
+    readonly media?: ReadonlyMap<string, CachedMediaMetadata>;
+    /**
+     * Cached text embeddings keyed by post content hash.
+     * When a post's hash matches a cached entry, embedding generation
+     * can be skipped and the cached vector used directly.
+     */
+    readonly textEmbeddings?: ReadonlyMap<string, readonly number[]>;
+    /**
+     * Cached image embeddings keyed by media content hash.
+     * When a media file's hash matches a cached entry, CLIP embedding
+     * generation can be skipped and the cached vector used directly.
+     */
+    readonly imageEmbeddings?: ReadonlyMap<string, readonly number[]>;
+}
+/**
+ * Statistics about cache usage during processing
+ */
+interface CacheStats {
+    /** Number of media files that used cached metadata */
+    readonly mediaCacheHits: number;
+    /** Number of media files that were processed fresh */
+    readonly mediaCacheMisses: number;
+    /** Number of posts that used cached text embeddings */
+    readonly textEmbeddingCacheHits: number;
+    /** Number of posts that required fresh text embedding generation */
+    readonly textEmbeddingCacheMisses: number;
+    /** Number of media files that used cached image embeddings */
+    readonly imageEmbeddingCacheHits: number;
+    /** Number of media files that required fresh image embedding generation */
+    readonly imageEmbeddingCacheMisses: number;
+}
+/**
+ * Create empty cache statistics
+ */
+declare const createEmptyCacheStats: () => CacheStats;
+/**
+ * Build a media cache from a medias.json file structure
+ */
+declare function buildMediaCacheFromManifest(medias: readonly {
+    metadata?: MediaMetadata;
+    outputPath: string;
+    sizes?: readonly MediaSizeVariant[];
+}[]): Map<string, CachedMediaMetadata>;
+/**
+ * Build an embedding cache from an embedding hash map file structure
+ */
+declare function buildEmbeddingCacheFromManifest(embeddingMap: Record<string, readonly number[]>): Map<string, readonly number[]>;
+
+/**
+ * Output types for @repo-md/processor-core
+ */
+
+interface TocItem {
+    readonly text: string;
+    readonly depth: number;
+    readonly slug: string;
+}
+interface PostMetadata {
+    readonly createdAt: string;
+    readonly modifiedAt: string;
+    readonly processedAt: string;
+    readonly gitCreatedAt?: string;
+    readonly gitModifiedAt?: string;
+}
+interface PostCoverSize {
+    /** Size suffix (xs, sm, md, lg, xl) */
+    readonly suffix: string;
+    /** Output file path relative to output dir */
+    readonly path: string;
+    /** Full URL if domain configured */
+    readonly url?: string;
+    /** Width of this variant */
+    readonly width: number;
+    /** Height of this variant */
+    readonly height: number;
+}
+interface PostCover {
+    /** Original path from frontmatter */
+    readonly original: string;
+    /** Output file path relative to output dir */
+    readonly path: string;
+    /** Full URL if domain configured */
+    readonly url?: string;
+    /** Content hash */
+    readonly hash?: string;
+    /** Image width */
+    readonly width?: number;
+    /** Image height */
+    readonly height?: number;
+    /** Responsive image size variants */
+    readonly sizes?: readonly PostCoverSize[];
+}
+interface PostCoverError {
+    /** Original path from frontmatter */
+    readonly original: string;
+    /** Error message explaining why cover couldn't be resolved */
+    readonly error: string;
+}
+interface ProcessedPost {
+    /** Content hash for identification */
+    readonly hash: string;
+    /** URL-friendly slug */
+    readonly slug: string;
+    /** Post title (from frontmatter or filename) */
+    readonly title: string;
+    /** Original filename without extension */
+    readonly fileName: string;
+    /** Original file path relative to input directory */
+    readonly originalPath: string;
+    /** Rendered HTML content */
+    readonly content: string;
+    /** Original markdown content */
+    readonly markdown: string;
+    /** Plain text content (for search/embeddings) */
+    readonly plainText: string;
+    /** Excerpt/summary text */
+    readonly excerpt: string;
+    /** Word count */
+    readonly wordCount: number;
+    /** Table of contents */
+    readonly toc: readonly TocItem[];
+    /** Frontmatter data */
+    readonly frontmatter: Readonly<Record<string, unknown>>;
+    /** Timestamps and metadata */
+    readonly metadata: PostMetadata;
+    /** Cover image (resolved from frontmatter.cover) */
+    readonly cover?: PostCover | PostCoverError;
+    /** URL of first image (for cover) */
+    readonly firstImage?: string;
+    /** Hashes of posts this post links to */
+    readonly links?: readonly string[];
+    /** Text embedding vector */
+    readonly embedding?: readonly number[];
+}
+interface MediaMetadata {
+    readonly width?: number;
+    readonly height?: number;
+    readonly format?: string;
+    readonly size?: number;
+    readonly originalSize?: number;
+    readonly hash?: string;
+}
+interface MediaSizeVariant {
+    /** Size suffix (xs, sm, md, lg, xl) */
+    readonly suffix: string;
+    /** Output file path relative to output dir */
+    readonly outputPath: string;
+    /** Width of this variant */
+    readonly width: number;
+    /** Height of this variant */
+    readonly height: number;
+    /** File size in bytes */
+    readonly size: number;
+}
+interface ProcessedMedia {
+    /** Original file path relative to input */
+    readonly originalPath: string;
+    /** Output file path relative to output dir */
+    readonly outputPath: string;
+    /** Original filename */
+    readonly fileName: string;
+    /** Media type */
+    readonly type: 'image' | 'video' | 'audio' | 'media';
+    /** File metadata */
+    readonly metadata?: MediaMetadata;
+    /** Responsive image size variants */
+    readonly sizes?: readonly MediaSizeVariant[];
+    /** Image embedding vector */
+    readonly embedding?: readonly number[];
+}
+type RelationshipType = 'POST_LINKS_TO_POST' | 'POST_USE_IMAGE';
+interface GraphNode {
+    readonly id: string;
+    readonly type: 'post' | 'media';
+    readonly label: string;
+}
+interface GraphEdge {
+    readonly source: string;
+    readonly target: string;
+    readonly type: RelationshipType;
+}
+interface GraphData {
+    readonly nodes: readonly GraphNode[];
+    readonly edges: readonly GraphEdge[];
+}
+/** Maps original paths to optimized public paths */
+type MediaPathMap = Readonly<Record<string, string>>;
+/** Maps original paths to content hashes */
+type PathHashMap = Readonly<Record<string, string>>;
+/** Maps slugs to post hashes */
+type SlugHashMap = Readonly<Record<string, string>>;
+/** Maps hashes to embedding vectors */
+type EmbeddingMap = ReadonlyMap<string, readonly number[]>;
+interface OutputFiles {
+    readonly posts: string;
+    readonly media: string;
+    readonly slugMap: string;
+    readonly pathMap: string;
+    readonly issues: string;
+    readonly graph?: string;
+    readonly similarity?: string;
+    readonly database?: string;
+}
+interface ProcessResult {
+    /** Processed posts */
+    readonly posts: readonly ProcessedPost[];
+    /** Processed media files */
+    readonly media: readonly ProcessedMedia[];
+    /** Output directory path */
+    readonly outputDir: string;
+    /** Output file paths */
+    readonly outputFiles: OutputFiles;
+    /** Processing issues report */
+    readonly issues: IssueReport;
+    /** Graph data (if trackRelationships enabled) */
+    readonly graph?: GraphData;
+    /** Cache statistics (if cache was provided) */
+    readonly cacheStats?: CacheStats;
+}
+declare const OUTPUT_FILES: {
+    readonly POSTS: "posts.json";
+    readonly POSTS_SLUG_MAP: "posts-slug-map.json";
+    readonly POSTS_PATH_MAP: "posts-path-map.json";
+    readonly MEDIAS: "media.json";
+    readonly MEDIA_PATH_MAP: "media-path-map.json";
+    readonly GRAPH: "graph.json";
+    readonly TEXT_EMBEDDINGS: "posts-embedding-hash-map.json";
+    readonly IMAGE_EMBEDDINGS: "media-embedding-hash-map.json";
+    readonly SIMILARITY: "similarity.json";
+    readonly DATABASE: "repo.db";
+    readonly ISSUES: "processor-issues.json";
+};
+
+/**
+ * Plugin system types for @repo-md/processor-core
+ *
+ * Plugins extend the processor with optional functionality like:
+ * - Image optimization (Sharp, Jimp, etc.)
+ * - Text embeddings (HuggingFace, OpenAI, Cloudflare)
+ * - Image embeddings (CLIP)
+ * - Database generation (SQLite)
+ * - Diagram rendering (Mermaid)
+ */
+
+/**
+ * Context provided to plugins during initialization
+ */
+interface PluginContext {
+    /** Output directory for generated files */
+    readonly outputDir: string;
+    /** Issue collector for reporting problems */
+    readonly issues: IssueCollector;
+    /** Logger function */
+    readonly log: (message: string, level?: LogLevel) => void;
+    /** Access to other initialized plugins */
+    readonly getPlugin: <T extends Plugin>(name: string) => T | undefined;
+    /** Current processor configuration */
+    readonly config: ProcessConfig;
+}
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Base interface for all plugins
+ */
+interface Plugin {
+    /** Unique plugin identifier */
+    readonly name: string;
+    /**
+     * Names of plugins this plugin depends on.
+     * Dependencies are initialized before this plugin.
+     */
+    readonly requires?: readonly string[];
+    /** Initialize the plugin with context */
+    initialize(context: PluginContext): Promise<void>;
+    /** Check if plugin is ready to use */
+    isReady(): boolean;
+    /** Optional cleanup method */
+    dispose?(): Promise<void>;
+}
+interface ImageMetadata {
+    readonly width: number;
+    readonly height: number;
+    readonly format: string;
+}
+interface ImageProcessOptions {
+    readonly width?: number;
+    readonly height?: number;
+    readonly format: 'webp' | 'avif' | 'jpeg' | 'png';
+    readonly quality?: number;
+}
+interface ImageProcessResult {
+    readonly outputPath: string;
+    readonly width: number;
+    readonly height: number;
+    readonly format: string;
+    readonly size: number;
+}
+/**
+ * Plugin for processing and optimizing images
+ */
+interface ImageProcessorPlugin extends Plugin {
+    readonly name: 'imageProcessor';
+    /** Check if this processor can handle the file type */
+    canProcess(filePath: string): boolean;
+    /** Get image metadata without processing */
+    getMetadata(filePath: string): Promise<ImageMetadata>;
+    /** Process/optimize an image */
+    process(inputPath: string, outputPath: string, options: ImageProcessOptions): Promise<ImageProcessResult>;
+    /** Copy file without processing */
+    copy(inputPath: string, outputPath: string): Promise<void>;
+}
+/**
+ * Plugin for generating text embeddings
+ */
+interface TextEmbeddingPlugin extends Plugin {
+    readonly name: 'textEmbedder';
+    /** Model identifier (e.g., "Xenova/all-MiniLM-L6-v2") */
+    readonly model: string;
+    /** Embedding vector dimensions */
+    readonly dimensions: number;
+    /** Generate embedding for a single text */
+    embed(text: string): Promise<readonly number[]>;
+    /** Generate embeddings for multiple texts */
+    batchEmbed(texts: readonly string[]): Promise<readonly (readonly number[])[]>;
+}
+/**
+ * Plugin for generating image embeddings (e.g., CLIP)
+ */
+interface ImageEmbeddingPlugin extends Plugin {
+    readonly name: 'imageEmbedder';
+    /** Model identifier */
+    readonly model: string;
+    /** Embedding vector dimensions */
+    readonly dimensions: number;
+    /** Generate embedding from image file path */
+    embedFile(filePath: string): Promise<readonly number[]>;
+    /** Generate embedding from image buffer */
+    embedBuffer(buffer: Buffer, mimeType: string): Promise<readonly number[]>;
+}
+interface SimilarityResult {
+    /** Map of "hash1-hash2" -> similarity score */
+    readonly pairwiseScores: ReadonlyMap<string, number>;
+    /** Map of hash -> array of similar hashes (sorted by similarity) */
+    readonly similarPosts: ReadonlyMap<string, readonly string[]>;
+    /** Metadata about the computation */
+    readonly metadata: {
+        readonly computedAt: string;
+        readonly postCount: number;
+        readonly pairCount: number;
+    };
+}
+/**
+ * Plugin for computing post similarity
+ * Requires: textEmbedder
+ */
+interface SimilarityPlugin extends Plugin {
+    readonly name: 'similarity';
+    readonly requires: readonly ['textEmbedder'];
+    /** Compute cosine similarity between two embedding vectors */
+    computeSimilarity(a: readonly number[], b: readonly number[]): number;
+    /** Generate similarity data for all posts */
+    generateSimilarityMap(posts: readonly ProcessedPost[]): Promise<SimilarityResult>;
+}
+interface DatabaseBuildInput {
+    readonly posts: readonly ProcessedPost[];
+    readonly media: readonly ProcessedMedia[];
+    readonly embeddings?: ReadonlyMap<string, readonly number[]>;
+    readonly imageEmbeddings?: ReadonlyMap<string, readonly number[]>;
+}
+interface DatabaseResult {
+    readonly databasePath: string;
+    readonly tables: readonly string[];
+    readonly rowCounts: Readonly<Record<string, number>>;
+    readonly hasVectorSearch: boolean;
+}
+/**
+ * Plugin for building a database from processed content
+ */
+interface DatabasePlugin extends Plugin {
+    readonly name: 'database';
+    /** Build database from processed data */
+    build(input: DatabaseBuildInput): Promise<DatabaseResult>;
+}
+type MermaidStrategy = 'img-png' | 'img-svg' | 'inline-svg' | 'pre-mermaid';
+interface MermaidRenderOptions {
+    readonly strategy: MermaidStrategy;
+    readonly dark?: boolean;
+}
+interface MermaidResult {
+    /** Rendered output (SVG string, base64 PNG, or original code) */
+    readonly output: string;
+    /** Strategy that was actually used */
+    readonly strategy: MermaidStrategy;
+}
+/**
+ * Plugin for rendering Mermaid diagrams
+ */
+interface MermaidRendererPlugin extends Plugin {
+    readonly name: 'mermaidRenderer';
+    /** Render mermaid code to specified format */
+    render(code: string, options: MermaidRenderOptions): Promise<MermaidResult>;
+    /** Check if renderer is available (e.g., has browser) */
+    isAvailable(): Promise<boolean>;
+}
+/**
+ * Type-safe plugin configuration for ProcessConfig
+ */
+interface PluginConfig {
+    /** Image processor plugin */
+    imageProcessor?: ImageProcessorPlugin;
+    /** Text embedding plugin */
+    textEmbedder?: TextEmbeddingPlugin;
+    /** Image embedding plugin */
+    imageEmbedder?: ImageEmbeddingPlugin;
+    /** Similarity computation plugin */
+    similarity?: SimilarityPlugin;
+    /** Database generation plugin */
+    database?: DatabasePlugin;
+    /** Mermaid rendering plugin */
+    mermaidRenderer?: MermaidRendererPlugin;
+}
+/**
+ * Union type of all plugin names
+ */
+type PluginName = keyof PluginConfig;
+/**
+ * Get plugin type by name
+ */
+type PluginByName<N extends PluginName> = NonNullable<PluginConfig[N]>;
+
+/**
+ * Configuration types for @repo-md/processor-core
+ */
+
+interface ImageSizeConfig {
+    readonly width: number | null;
+    readonly height: number | null;
+    readonly suffix: string;
+}
+/** Default image sizes for responsive images */
+declare const DEFAULT_IMAGE_SIZES: readonly ImageSizeConfig[];
+interface DirectoryConfig {
+    /** Base directory for resolving relative paths (default: cwd) */
+    readonly base?: string;
+    /** Input directory */
+    readonly input: string;
+    /** Output directory for generated files (default: input + '/dist') */
+    readonly output?: string;
+    /** Media output subdirectory (default: '_media') */
+    readonly mediaOutput?: string;
+    /** Posts output subdirectory for individual post JSON files */
+    readonly postsOutput?: string;
+}
+interface MediaConfig {
+    /** Skip media processing entirely */
+    readonly skip?: boolean;
+    /** Whether to optimize images (default: true if imageProcessor plugin available) */
+    readonly optimize?: boolean;
+    /** Image sizes to generate */
+    readonly sizes?: readonly ImageSizeConfig[];
+    /** Output format for optimized images (default: 'webp') */
+    readonly format?: 'webp' | 'avif' | 'jpeg' | 'png';
+    /** Quality for lossy formats (default: 80) */
+    readonly quality?: number;
+    /** Whether to use content hash for filenames (default: true) */
+    readonly useHash?: boolean;
+    /** Whether to shard hashed files by first 2 chars (default: false) */
+    readonly useSharding?: boolean;
+    /** Domain for absolute URLs */
+    readonly domain?: string;
+    /** Asset path prefix (default: '/_media') */
+    readonly pathPrefix?: string;
+}
+interface ContentConfig {
+    /** URL prefix for notes (default: '/content') */
+    readonly notePathPrefix?: string;
+    /** Whether to process all files regardless of 'public' frontmatter */
+    readonly processAllFiles?: boolean;
+    /** Files to ignore during processing */
+    readonly ignoreFiles?: readonly string[];
+    /** Whether to export individual post JSON files */
+    readonly exportPosts?: boolean;
+    /** Whether to track relationships between posts */
+    readonly trackRelationships?: boolean;
+    /** Include slug tracking information in output */
+    readonly includeSlugTracking?: boolean;
+    /** Strategy for resolving slug conflicts */
+    readonly slugConflictStrategy?: 'number' | 'hash';
+    /** Scope for slug deduplication: 'global' (default) or 'top-folder' (per top-level directory) */
+    readonly slugScope?: 'global' | 'top-folder';
+}
+interface MermaidConfig {
+    /** Whether mermaid rendering is enabled (default: true) */
+    readonly enabled?: boolean;
+    /** Rendering strategy (default: 'inline-svg') */
+    readonly strategy?: 'img-png' | 'img-svg' | 'inline-svg' | 'pre-mermaid';
+    /** Enable dark mode support */
+    readonly dark?: boolean;
+    /** Custom mermaid configuration */
+    readonly mermaidConfig?: Readonly<Record<string, unknown>>;
+}
+interface PipelineConfig {
+    /** Enable GitHub Flavored Markdown (default: true) */
+    readonly gfm?: boolean;
+    /** Allow raw HTML in markdown (default: true) */
+    readonly allowRawHtml?: boolean;
+    /** Enable syntax highlighting for code blocks (default: true) */
+    readonly syntaxHighlighting?: boolean;
+    /** Enable LaTeX formula parsing (default: false) */
+    readonly parseFormulas?: boolean;
+    /** Remove broken/dead links instead of keeping them (default: false) */
+    readonly removeDeadLinks?: boolean;
+    /** Enable wiki-link resolution ([[Page Name]] → <a href="/slug">) (default: true) */
+    readonly wikiLinks?: boolean;
+}
+interface DebugConfig {
+    /** Debug level (0=off, 1=basic, 2=verbose) */
+    readonly level?: number;
+    /** Log timing information */
+    readonly timing?: boolean;
+}
+interface ProcessConfig {
+    /** Directory configuration */
+    readonly dir: DirectoryConfig;
+    /** Plugin configuration */
+    readonly plugins?: PluginConfig;
+    /** Media processing configuration */
+    readonly media?: MediaConfig;
+    /** Content processing configuration */
+    readonly content?: ContentConfig;
+    /** Mermaid rendering configuration */
+    readonly mermaid?: MermaidConfig;
+    /** Markdown pipeline configuration */
+    readonly pipeline?: PipelineConfig;
+    /** Debug configuration */
+    readonly debug?: DebugConfig;
+    /**
+     * Cache context for incremental builds.
+     * When provided, the processor will skip processing files
+     * whose content hash matches a cached entry and use cached metadata instead.
+     */
+    readonly cache?: CacheContext;
+}
+/**
+ * ProcessConfig with all fields required except cache (which remains optional)
+ */
+type ProcessConfigWithDefaults = Required<Omit<ProcessConfig, 'cache'>> & {
+    cache?: CacheContext;
+};
+/**
+ * Merge configuration with defaults
+ */
+declare const withDefaults: (config: ProcessConfig) => ProcessConfigWithDefaults;
+/**
+ * Get output directory from config
+ */
+declare const getOutputDir: (config: ProcessConfig) => string;
+/**
+ * Get media output directory from config
+ */
+declare const getMediaOutputDir: (config: ProcessConfig) => string;
+
+export { type PluginName as $, type MediaPathMap as A, type BrokenLinkIssue as B, type CacheContext as C, DEFAULT_IMAGE_SIZES as D, type EmbeddingErrorIssue as E, type MediaProcessingIssue as F, type GraphData as G, type MediaSizeVariant as H, type ImageEmbeddingPlugin as I, type MermaidConfig as J, type MermaidErrorIssue as K, type LogLevel as L, type MediaConfig as M, type MermaidRenderOptions as N, type MermaidRendererPlugin as O, type MermaidResult as P, type MermaidStrategy as Q, type MissingMediaIssue as R, OUTPUT_FILES as S, type OutputFiles as T, type PathHashMap as U, type PipelineConfig as V, type Plugin as W, type PluginByName as X, type PluginConfig as Y, type PluginContext as Z, type PluginErrorIssue as _, type CacheStats as a, type PostCover as a0, type PostCoverError as a1, type PostCoverSize as a2, type PostMetadata as a3, type ProcessConfig as a4, type ProcessConfigWithDefaults as a5, type ProcessResult as a6, type ProcessedMedia as a7, type ProcessedPost as a8, type ProcessingIssue as a9, type RelationshipType as aa, type SimilarityPlugin as ab, type SimilarityResult as ac, type SlugConflictIssue as ad, type SlugHashMap as ae, type TextEmbeddingPlugin as af, type TocItem as ag, buildEmbeddingCacheFromManifest as ah, buildMediaCacheFromManifest as ai, calculateSummary as aj, createEmptyCacheStats as ak, filterIssues as al, generateIssueReport as am, getMediaOutputDir as an, getOutputDir as ao, isBrokenLinkIssue as ap, isEmbeddingErrorIssue as aq, isMediaProcessingIssue as ar, isMermaidErrorIssue as as, isMissingMediaIssue as at, isPluginErrorIssue as au, isSlugConflictIssue as av, withDefaults as aw, type CachedMediaMetadata as b, type CachedMediaSizeVariant as c, type ContentConfig as d, type DatabaseBuildInput as e, type DatabasePlugin as f, type DatabaseResult as g, type DebugConfig as h, type DirectoryConfig as i, type EmbeddingMap as j, type GraphEdge as k, type GraphNode as l, type ImageMetadata as m, type ImageProcessOptions as n, type ImageProcessResult as o, type ImageProcessorPlugin as p, type ImageSizeConfig as q, type IssueCategory as r, IssueCollector as s, type IssueCollectorState as t, type IssueFilterOptions as u, type IssueModule as v, type IssueReport as w, type IssueSeverity as x, type IssueSummary as y, type MediaMetadata as z };