folderblog 0.0.2 → 0.0.3

package/dist/output-0P0br3Jc.d.ts

@@ -0,0 +1,452 @@
+/**
+ * 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[];
+}
+
+/**
+ * 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 BuildReport {
+    /** Text embedding stats (if embeddings were generated) */
+    readonly postEmbeddings?: {
+        readonly filesProcessed: number;
+        readonly dimensions: number;
+        readonly model: string;
+    };
+    /** Image embedding stats (if image embeddings were generated) */
+    readonly mediaEmbeddings?: {
+        readonly filesProcessed: number;
+        readonly dimensions: number;
+        readonly model: string;
+    };
+    /** Similarity computation stats */
+    readonly similarity?: {
+        readonly pairsComputed: number;
+        readonly topN: number;
+        readonly postsWithEmbeddings: number;
+    };
+    /** Phase timing in milliseconds */
+    readonly timing?: {
+        readonly totalMs: number;
+        readonly phases: Readonly<Record<string, number>>;
+    };
+}
+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;
+    /** Build report with stats about embeddings, similarity, timing */
+    readonly report?: BuildReport;
+}
+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";
+};
+
+export { type ProcessResult as A, type BrokenLinkIssue as B, type CacheContext as C, type SlugHashMap as D, type EmbeddingErrorIssue as E, buildEmbeddingCacheFromManifest as F, type GraphData as G, buildMediaCacheFromManifest as H, type IssueFilterOptions as I, createEmptyCacheStats as J, isBrokenLinkIssue as K, isEmbeddingErrorIssue as L, type MediaMetadata as M, isMediaProcessingIssue as N, OUTPUT_FILES as O, type ProcessingIssue as P, isMermaidErrorIssue as Q, type RelationshipType as R, type SlugConflictIssue as S, type TocItem as T, isMissingMediaIssue as U, isPluginErrorIssue as V, isSlugConflictIssue as W, type IssueSeverity as a, type IssueReport as b, type IssueSummary as c, type ProcessedPost as d, type ProcessedMedia as e, type BuildReport as f, type CacheStats as g, type CachedMediaMetadata as h, type CachedMediaSizeVariant as i, type EmbeddingMap as j, type GraphEdge as k, type GraphNode as l, type IssueCategory as m, type IssueModule as n, type MediaPathMap as o, type MediaProcessingIssue as p, type MediaSizeVariant as q, type MermaidErrorIssue as r, type MissingMediaIssue as s, type OutputFiles as t, type PathHashMap as u, type PluginErrorIssue as v, type PostCover as w, type PostCoverError as x, type PostCoverSize as y, type PostMetadata as z };

package/dist/plugins/embed-cloudflare-ai.cjs

@@ -0,0 +1,166 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../chunk-OBGZSXTJ.cjs');
+
+// src/plugins/embed-cloudflare-ai.ts
+var DEFAULT_MODEL = "@cf/baai/bge-small-en-v1.5";
+var MODEL_DIMENSIONS = {
+  "@cf/baai/bge-small-en-v1.5": 384,
+  "@cf/baai/bge-base-en-v1.5": 768,
+  "@cf/baai/bge-large-en-v1.5": 1024,
+  "@cf/baai/bge-m3": 1024
+};
+var CloudflareAITextEmbedder = class {
+  name = "textEmbedder";
+  model;
+  dimensions;
+  ready = false;
+  context = null;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      binding: options.binding,
+      accountId: options.accountId,
+      apiToken: options.apiToken,
+      modelId: options.modelId ?? DEFAULT_MODEL,
+      pooling: options.pooling ?? "cls",
+      batchSize: options.batchSize ?? 100,
+      timeout: options.timeout ?? 3e4
+    };
+    this.model = this.options.modelId;
+    this.dimensions = MODEL_DIMENSIONS[this.model] ?? 384;
+  }
+  async initialize(context) {
+    this.context = context;
+    const mode = this.options.binding ? "binding" : "REST API";
+    context.log(
+      `Initializing CloudflareAITextEmbedder (${mode} mode, model: ${this.model}, pooling: ${this.options.pooling})`,
+      "info"
+    );
+    if (!this.options.binding && (!this.options.accountId || !this.options.apiToken)) {
+      throw new Error(
+        "CloudflareAITextEmbedder requires either a binding (env.AI) or accountId + apiToken for REST API mode"
+      );
+    }
+    try {
+      await this.embed("test");
+      context.log(
+        `CloudflareAITextEmbedder initialized (${this.dimensions} dimensions)`,
+        "info"
+      );
+      this.ready = true;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      context.log(`Failed to initialize Cloudflare AI embedder: ${msg}`, "error");
+      throw error;
+    }
+  }
+  isReady() {
+    return this.ready;
+  }
+  async dispose() {
+    this.ready = false;
+  }
+  async embed(text) {
+    const results = await this.batchEmbed([text]);
+    const result = results[0];
+    if (!result) {
+      throw new Error("Failed to generate embedding");
+    }
+    return result;
+  }
+  async batchEmbed(texts) {
+    if (texts.length === 0) {
+      return [];
+    }
+    const results = [];
+    const batchSize = this.options.batchSize;
+    for (let i = 0; i < texts.length; i += batchSize) {
+      const batch = texts.slice(i, i + batchSize);
+      const batchResults = await this.embedBatch(batch);
+      results.push(...batchResults);
+      if (texts.length > 50 && this.context) {
+        this.context.log(
+          `Embedding progress: ${Math.min(i + batchSize, texts.length)}/${texts.length}`,
+          "debug"
+        );
+      }
+    }
+    return results;
+  }
+  async embedBatch(texts) {
+    if (this.options.binding) {
+      return this.embedWithBinding(texts);
+    }
+    return this.embedWithRestApi(texts);
+  }
+  async embedWithBinding(texts) {
+    const binding = this.options.binding;
+    const response = await binding.run(this.model, {
+      text: texts,
+      pooling: this.options.pooling
+    });
+    if (!response?.data) {
+      throw new Error("Invalid response from Cloudflare AI binding");
+    }
+    return response.data;
+  }
+  async embedWithRestApi(texts) {
+    const url = `https://api.cloudflare.com/client/v4/accounts/${this.options.accountId}/ai/run/${this.model}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.options.apiToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          text: texts,
+          pooling: this.options.pooling
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Cloudflare AI API error (${response.status}): ${errorText}`);
+      }
+      const data = await response.json();
+      if (!data.success || !data.result?.data) {
+        const errorMsg = data.errors?.[0]?.message ?? "Unknown error";
+        throw new Error(`Cloudflare AI API error: ${errorMsg}`);
+      }
+      return data.result.data;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+var createCloudflareAIEmbedderWithBinding = (binding, options) => {
+  return new CloudflareAITextEmbedder({ ...options, binding });
+};
+var createCloudflareAIEmbedderWithRestApi = (accountId, apiToken, options) => {
+  return new CloudflareAITextEmbedder({ ...options, accountId, apiToken });
+};
+var createCloudflareAIEmbedderFromEnv = (options) => {
+  const accountId = process.env["CLOUDFLARE_ACCOUNT_ID"];
+  const apiToken = process.env["CLOUDFLARE_API_TOKEN"];
+  if (!accountId || !apiToken) {
+    throw new Error(
+      "CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN environment variables are required"
+    );
+  }
+  return new CloudflareAITextEmbedder({ ...options, accountId, apiToken });
+};
+var embed_cloudflare_ai_default = CloudflareAITextEmbedder;
+
+exports.CLOUDFLARE_DEFAULT_MODEL = DEFAULT_MODEL;
+exports.CLOUDFLARE_MODEL_DIMENSIONS = MODEL_DIMENSIONS;
+exports.CloudflareAITextEmbedder = CloudflareAITextEmbedder;
+exports.createCloudflareAIEmbedderFromEnv = createCloudflareAIEmbedderFromEnv;
+exports.createCloudflareAIEmbedderWithBinding = createCloudflareAIEmbedderWithBinding;
+exports.createCloudflareAIEmbedderWithRestApi = createCloudflareAIEmbedderWithRestApi;
+exports.default = embed_cloudflare_ai_default;

package/dist/plugins/embed-cloudflare-ai.d.cts

@@ -0,0 +1,73 @@
+import { T as TextEmbeddingPlugin, P as PluginContext } from '../config-ADPY6IQS.cjs';
+import '../output-0P0br3Jc.cjs';
+
+/**
+ * Cloudflare Workers AI Text Embedding Plugin
+ *
+ * Uses Cloudflare Workers AI for text embeddings.
+ * Supports both:
+ * - Binding mode: When running inside a Cloudflare Worker (env.AI)
+ * - REST API mode: When running outside CF (uses fetch)
+ *
+ * Available models:
+ * - @cf/baai/bge-small-en-v1.5 (384 dims, fast, English)
+ * - @cf/baai/bge-base-en-v1.5 (768 dims, balanced, English)
+ * - @cf/baai/bge-large-en-v1.5 (1024 dims, best quality, English)
+ * - @cf/baai/bge-m3 (1024 dims, multilingual)
+ *
+ * @example
+ * ```ts
+ * // In a Cloudflare Worker:
+ * import { createCloudflareAIEmbedderWithBinding } from 'folderblog/plugins/embed-cloudflare-ai';
+ * const embedder = createCloudflareAIEmbedderWithBinding(env.AI);
+ *
+ * // External via REST API:
+ * import { createCloudflareAIEmbedderFromEnv } from 'folderblog/plugins/embed-cloudflare-ai';
+ * const embedder = createCloudflareAIEmbedderFromEnv();
+ * ```
+ */
+
+interface CloudflareAIBinding {
+    run<T = unknown>(model: string, input: Record<string, unknown>): Promise<T>;
+}
+type PoolingStrategy = 'mean' | 'cls';
+interface CloudflareAIEmbedderOptions {
+    /** Cloudflare Workers AI binding (env.AI). When provided, uses direct binding. */
+    readonly binding?: CloudflareAIBinding;
+    /** Cloudflare Account ID (required for REST API mode) */
+    readonly accountId?: string;
+    /** Cloudflare API Token with Workers AI permissions (required for REST API mode) */
+    readonly apiToken?: string;
+    /** Model ID (default: '@cf/baai/bge-small-en-v1.5') */
+    readonly modelId?: string;
+    /** Pooling strategy (default: 'cls' for better accuracy) */
+    readonly pooling?: PoolingStrategy;
+    /** Batch size for concurrent requests (default: 100) */
+    readonly batchSize?: number;
+    /** Request timeout in ms (default: 30000) */
+    readonly timeout?: number;
+}
+declare const DEFAULT_MODEL = "@cf/baai/bge-small-en-v1.5";
+declare const MODEL_DIMENSIONS: Record<string, number>;
+declare class CloudflareAITextEmbedder implements TextEmbeddingPlugin {
+    readonly name: "textEmbedder";
+    readonly model: string;
+    readonly dimensions: number;
+    private ready;
+    private context;
+    private options;
+    constructor(options?: CloudflareAIEmbedderOptions);
+    initialize(context: PluginContext): Promise<void>;
+    isReady(): boolean;
+    dispose(): Promise<void>;
+    embed(text: string): Promise<readonly number[]>;
+    batchEmbed(texts: readonly string[]): Promise<readonly (readonly number[])[]>;
+    private embedBatch;
+    private embedWithBinding;
+    private embedWithRestApi;
+}
+declare const createCloudflareAIEmbedderWithBinding: (binding: CloudflareAIBinding, options?: Omit<CloudflareAIEmbedderOptions, "binding" | "accountId" | "apiToken">) => TextEmbeddingPlugin;
+declare const createCloudflareAIEmbedderWithRestApi: (accountId: string, apiToken: string, options?: Omit<CloudflareAIEmbedderOptions, "binding" | "accountId" | "apiToken">) => TextEmbeddingPlugin;
+declare const createCloudflareAIEmbedderFromEnv: (options?: Omit<CloudflareAIEmbedderOptions, "binding" | "accountId" | "apiToken">) => TextEmbeddingPlugin;
+
+export { DEFAULT_MODEL as CLOUDFLARE_DEFAULT_MODEL, MODEL_DIMENSIONS as CLOUDFLARE_MODEL_DIMENSIONS, type CloudflareAIBinding, type CloudflareAIEmbedderOptions, CloudflareAITextEmbedder, type PoolingStrategy, createCloudflareAIEmbedderFromEnv, createCloudflareAIEmbedderWithBinding, createCloudflareAIEmbedderWithRestApi, CloudflareAITextEmbedder as default };