@kreuzberg/kreuzcrawl 0.1.0-rc.2

package/src/lib.rs

@@ -0,0 +1,1921 @@
+// This file is auto-generated by alef. DO NOT EDIT.
+// Re-generate with: alef generate
+#![allow(dead_code)]
+
+use napi::*;
+use napi_derive::napi;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+static WORKER_POOL: std::sync::LazyLock<tokio::runtime::Runtime> = std::sync::LazyLock::new(|| {
+    tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()
+        .expect("Failed to create Tokio runtime")
+});
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsExtractionMeta {
+    pub cost: Option<f64>,
+    #[napi(js_name = "promptTokens")]
+    pub prompt_tokens: Option<i64>,
+    #[napi(js_name = "completionTokens")]
+    pub completion_tokens: Option<i64>,
+    pub model: Option<String>,
+    #[napi(js_name = "chunksProcessed")]
+    pub chunks_processed: Option<i64>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsProxyConfig {
+    pub url: Option<String>,
+    pub username: Option<String>,
+    pub password: Option<String>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsBrowserConfig {
+    pub mode: Option<JsBrowserMode>,
+    pub endpoint: Option<String>,
+    pub timeout: Option<i64>,
+    pub wait: Option<JsBrowserWait>,
+    #[napi(js_name = "waitSelector")]
+    pub wait_selector: Option<String>,
+    #[napi(js_name = "extraWait")]
+    pub extra_wait: Option<i64>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsCrawlConfig {
+    #[napi(js_name = "maxDepth")]
+    pub max_depth: Option<i64>,
+    #[napi(js_name = "maxPages")]
+    pub max_pages: Option<i64>,
+    #[napi(js_name = "maxConcurrent")]
+    pub max_concurrent: Option<i64>,
+    #[napi(js_name = "respectRobotsTxt")]
+    pub respect_robots_txt: Option<bool>,
+    #[napi(js_name = "userAgent")]
+    pub user_agent: Option<String>,
+    #[napi(js_name = "stayOnDomain")]
+    pub stay_on_domain: Option<bool>,
+    #[napi(js_name = "allowSubdomains")]
+    pub allow_subdomains: Option<bool>,
+    #[napi(js_name = "includePaths")]
+    pub include_paths: Option<Vec<String>>,
+    #[napi(js_name = "excludePaths")]
+    pub exclude_paths: Option<Vec<String>>,
+    #[napi(js_name = "customHeaders")]
+    pub custom_headers: Option<HashMap<String, String>>,
+    #[napi(js_name = "requestTimeout")]
+    pub request_timeout: Option<i64>,
+    #[napi(js_name = "maxRedirects")]
+    pub max_redirects: Option<i64>,
+    #[napi(js_name = "retryCount")]
+    pub retry_count: Option<i64>,
+    #[napi(js_name = "retryCodes")]
+    pub retry_codes: Option<Vec<u16>>,
+    #[napi(js_name = "cookiesEnabled")]
+    pub cookies_enabled: Option<bool>,
+    pub auth: Option<JsAuthConfig>,
+    #[napi(js_name = "maxBodySize")]
+    pub max_body_size: Option<i64>,
+    #[napi(js_name = "mainContentOnly")]
+    pub main_content_only: Option<bool>,
+    #[napi(js_name = "removeTags")]
+    pub remove_tags: Option<Vec<String>>,
+    #[napi(js_name = "mapLimit")]
+    pub map_limit: Option<i64>,
+    #[napi(js_name = "mapSearch")]
+    pub map_search: Option<String>,
+    #[napi(js_name = "downloadAssets")]
+    pub download_assets: Option<bool>,
+    #[napi(js_name = "assetTypes")]
+    pub asset_types: Option<Vec<JsAssetCategory>>,
+    #[napi(js_name = "maxAssetSize")]
+    pub max_asset_size: Option<i64>,
+    pub browser: Option<JsBrowserConfig>,
+    pub proxy: Option<JsProxyConfig>,
+    #[napi(js_name = "userAgents")]
+    pub user_agents: Option<Vec<String>>,
+    #[napi(js_name = "captureScreenshot")]
+    pub capture_screenshot: Option<bool>,
+    #[napi(js_name = "downloadDocuments")]
+    pub download_documents: Option<bool>,
+    #[napi(js_name = "documentMaxSize")]
+    pub document_max_size: Option<i64>,
+    #[napi(js_name = "documentMimeTypes")]
+    pub document_mime_types: Option<Vec<String>>,
+    #[napi(js_name = "warcOutput")]
+    pub warc_output: Option<String>,
+    #[napi(js_name = "browserProfile")]
+    pub browser_profile: Option<String>,
+    #[napi(js_name = "saveBrowserProfile")]
+    pub save_browser_profile: Option<bool>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsDownloadedDocument {
+    pub url: Option<String>,
+    #[napi(js_name = "mimeType")]
+    pub mime_type: Option<String>,
+    pub content: Option<Vec<u8>>,
+    pub size: Option<i64>,
+    pub filename: Option<String>,
+    #[napi(js_name = "contentHash")]
+    pub content_hash: Option<String>,
+    pub headers: Option<HashMap<String, String>>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsInteractionResult {
+    #[napi(js_name = "actionResults")]
+    pub action_results: Option<Vec<JsActionResult>>,
+    #[napi(js_name = "finalHtml")]
+    pub final_html: Option<String>,
+    #[napi(js_name = "finalUrl")]
+    pub final_url: Option<String>,
+    pub screenshot: Option<Vec<u8>>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsActionResult {
+    #[napi(js_name = "actionIndex")]
+    pub action_index: Option<i64>,
+    #[napi(js_name = "actionType")]
+    pub action_type: Option<String>,
+    pub success: Option<bool>,
+    pub data: Option<String>,
+    pub error: Option<String>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsScrapeResult {
+    #[napi(js_name = "statusCode")]
+    pub status_code: Option<u16>,
+    #[napi(js_name = "contentType")]
+    pub content_type: Option<String>,
+    pub html: Option<String>,
+    #[napi(js_name = "bodySize")]
+    pub body_size: Option<i64>,
+    pub metadata: Option<JsPageMetadata>,
+    pub links: Option<Vec<JsLinkInfo>>,
+    pub images: Option<Vec<JsImageInfo>>,
+    pub feeds: Option<Vec<JsFeedInfo>>,
+    #[napi(js_name = "jsonLd")]
+    pub json_ld: Option<Vec<JsJsonLdEntry>>,
+    #[napi(js_name = "isAllowed")]
+    pub is_allowed: Option<bool>,
+    #[napi(js_name = "crawlDelay")]
+    pub crawl_delay: Option<i64>,
+    #[napi(js_name = "noindexDetected")]
+    pub noindex_detected: Option<bool>,
+    #[napi(js_name = "nofollowDetected")]
+    pub nofollow_detected: Option<bool>,
+    #[napi(js_name = "xRobotsTag")]
+    pub x_robots_tag: Option<String>,
+    #[napi(js_name = "isPdf")]
+    pub is_pdf: Option<bool>,
+    #[napi(js_name = "wasSkipped")]
+    pub was_skipped: Option<bool>,
+    #[napi(js_name = "detectedCharset")]
+    pub detected_charset: Option<String>,
+    #[napi(js_name = "mainContentOnly")]
+    pub main_content_only: Option<bool>,
+    #[napi(js_name = "authHeaderSent")]
+    pub auth_header_sent: Option<bool>,
+    #[napi(js_name = "responseMeta")]
+    pub response_meta: Option<JsResponseMeta>,
+    pub assets: Option<Vec<JsDownloadedAsset>>,
+    #[napi(js_name = "jsRenderHint")]
+    pub js_render_hint: Option<bool>,
+    #[napi(js_name = "browserUsed")]
+    pub browser_used: Option<bool>,
+    pub markdown: Option<JsMarkdownResult>,
+    #[napi(js_name = "extractedData")]
+    pub extracted_data: Option<String>,
+    #[napi(js_name = "extractionMeta")]
+    pub extraction_meta: Option<JsExtractionMeta>,
+    pub screenshot: Option<Vec<u8>>,
+    #[napi(js_name = "downloadedDocument")]
+    pub downloaded_document: Option<JsDownloadedDocument>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsCrawlPageResult {
+    pub url: Option<String>,
+    #[napi(js_name = "normalizedUrl")]
+    pub normalized_url: Option<String>,
+    #[napi(js_name = "statusCode")]
+    pub status_code: Option<u16>,
+    #[napi(js_name = "contentType")]
+    pub content_type: Option<String>,
+    pub html: Option<String>,
+    #[napi(js_name = "bodySize")]
+    pub body_size: Option<i64>,
+    pub metadata: Option<JsPageMetadata>,
+    pub links: Option<Vec<JsLinkInfo>>,
+    pub images: Option<Vec<JsImageInfo>>,
+    pub feeds: Option<Vec<JsFeedInfo>>,
+    #[napi(js_name = "jsonLd")]
+    pub json_ld: Option<Vec<JsJsonLdEntry>>,
+    pub depth: Option<i64>,
+    #[napi(js_name = "stayedOnDomain")]
+    pub stayed_on_domain: Option<bool>,
+    #[napi(js_name = "wasSkipped")]
+    pub was_skipped: Option<bool>,
+    #[napi(js_name = "isPdf")]
+    pub is_pdf: Option<bool>,
+    #[napi(js_name = "detectedCharset")]
+    pub detected_charset: Option<String>,
+    pub markdown: Option<JsMarkdownResult>,
+    #[napi(js_name = "extractedData")]
+    pub extracted_data: Option<String>,
+    #[napi(js_name = "extractionMeta")]
+    pub extraction_meta: Option<JsExtractionMeta>,
+    #[napi(js_name = "downloadedDocument")]
+    pub downloaded_document: Option<JsDownloadedDocument>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsCrawlResult {
+    pub pages: Option<Vec<JsCrawlPageResult>>,
+    #[napi(js_name = "finalUrl")]
+    pub final_url: Option<String>,
+    #[napi(js_name = "redirectCount")]
+    pub redirect_count: Option<i64>,
+    #[napi(js_name = "wasSkipped")]
+    pub was_skipped: Option<bool>,
+    pub error: Option<String>,
+    pub cookies: Option<Vec<JsCookieInfo>>,
+    #[napi(js_name = "normalizedUrls")]
+    pub normalized_urls: Option<Vec<String>>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsSitemapUrl {
+    pub url: Option<String>,
+    pub lastmod: Option<String>,
+    pub changefreq: Option<String>,
+    pub priority: Option<String>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsMapResult {
+    pub urls: Option<Vec<JsSitemapUrl>>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsMarkdownResult {
+    pub content: Option<String>,
+    #[napi(js_name = "documentStructure")]
+    pub document_structure: Option<String>,
+    pub tables: Option<Vec<String>>,
+    pub warnings: Option<Vec<String>>,
+    pub citations: Option<JsCitationResult>,
+    #[napi(js_name = "fitContent")]
+    pub fit_content: Option<String>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsCachedPage {
+    pub url: Option<String>,
+    #[napi(js_name = "statusCode")]
+    pub status_code: Option<u16>,
+    #[napi(js_name = "contentType")]
+    pub content_type: Option<String>,
+    pub body: Option<String>,
+    pub etag: Option<String>,
+    #[napi(js_name = "lastModified")]
+    pub last_modified: Option<String>,
+    #[napi(js_name = "cachedAt")]
+    pub cached_at: Option<i64>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsLinkInfo {
+    pub url: Option<String>,
+    pub text: Option<String>,
+    #[napi(js_name = "linkType")]
+    pub link_type: Option<JsLinkType>,
+    pub rel: Option<String>,
+    pub nofollow: Option<bool>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsImageInfo {
+    pub url: Option<String>,
+    pub alt: Option<String>,
+    pub width: Option<u32>,
+    pub height: Option<u32>,
+    pub source: Option<JsImageSource>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsFeedInfo {
+    pub url: Option<String>,
+    pub title: Option<String>,
+    #[napi(js_name = "feedType")]
+    pub feed_type: Option<JsFeedType>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsJsonLdEntry {
+    #[napi(js_name = "schemaType")]
+    pub schema_type: Option<String>,
+    pub name: Option<String>,
+    pub raw: Option<String>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsCookieInfo {
+    pub name: Option<String>,
+    pub value: Option<String>,
+    pub domain: Option<String>,
+    pub path: Option<String>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsDownloadedAsset {
+    pub url: Option<String>,
+    #[napi(js_name = "contentHash")]
+    pub content_hash: Option<String>,
+    #[napi(js_name = "mimeType")]
+    pub mime_type: Option<String>,
+    pub size: Option<i64>,
+    #[napi(js_name = "assetCategory")]
+    pub asset_category: Option<JsAssetCategory>,
+    #[napi(js_name = "htmlTag")]
+    pub html_tag: Option<String>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsArticleMetadata {
+    #[napi(js_name = "publishedTime")]
+    pub published_time: Option<String>,
+    #[napi(js_name = "modifiedTime")]
+    pub modified_time: Option<String>,
+    pub author: Option<String>,
+    pub section: Option<String>,
+    pub tags: Option<Vec<String>>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsHreflangEntry {
+    pub lang: Option<String>,
+    pub url: Option<String>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsFaviconInfo {
+    pub url: Option<String>,
+    pub rel: Option<String>,
+    pub sizes: Option<String>,
+    #[napi(js_name = "mimeType")]
+    pub mime_type: Option<String>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsHeadingInfo {
+    pub level: Option<u8>,
+    pub text: Option<String>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsResponseMeta {
+    pub etag: Option<String>,
+    #[napi(js_name = "lastModified")]
+    pub last_modified: Option<String>,
+    #[napi(js_name = "cacheControl")]
+    pub cache_control: Option<String>,
+    pub server: Option<String>,
+    #[napi(js_name = "xPoweredBy")]
+    pub x_powered_by: Option<String>,
+    #[napi(js_name = "contentLanguage")]
+    pub content_language: Option<String>,
+    #[napi(js_name = "contentEncoding")]
+    pub content_encoding: Option<String>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsPageMetadata {
+    pub title: Option<String>,
+    pub description: Option<String>,
+    #[napi(js_name = "canonicalUrl")]
+    pub canonical_url: Option<String>,
+    pub keywords: Option<String>,
+    pub author: Option<String>,
+    pub viewport: Option<String>,
+    #[napi(js_name = "themeColor")]
+    pub theme_color: Option<String>,
+    pub generator: Option<String>,
+    pub robots: Option<String>,
+    #[napi(js_name = "htmlLang")]
+    pub html_lang: Option<String>,
+    #[napi(js_name = "htmlDir")]
+    pub html_dir: Option<String>,
+    #[napi(js_name = "ogTitle")]
+    pub og_title: Option<String>,
+    #[napi(js_name = "ogType")]
+    pub og_type: Option<String>,
+    #[napi(js_name = "ogImage")]
+    pub og_image: Option<String>,
+    #[napi(js_name = "ogDescription")]
+    pub og_description: Option<String>,
+    #[napi(js_name = "ogUrl")]
+    pub og_url: Option<String>,
+    #[napi(js_name = "ogSiteName")]
+    pub og_site_name: Option<String>,
+    #[napi(js_name = "ogLocale")]
+    pub og_locale: Option<String>,
+    #[napi(js_name = "ogVideo")]
+    pub og_video: Option<String>,
+    #[napi(js_name = "ogAudio")]
+    pub og_audio: Option<String>,
+    #[napi(js_name = "ogLocaleAlternates")]
+    pub og_locale_alternates: Option<Vec<String>>,
+    #[napi(js_name = "twitterCard")]
+    pub twitter_card: Option<String>,
+    #[napi(js_name = "twitterTitle")]
+    pub twitter_title: Option<String>,
+    #[napi(js_name = "twitterDescription")]
+    pub twitter_description: Option<String>,
+    #[napi(js_name = "twitterImage")]
+    pub twitter_image: Option<String>,
+    #[napi(js_name = "twitterSite")]
+    pub twitter_site: Option<String>,
+    #[napi(js_name = "twitterCreator")]
+    pub twitter_creator: Option<String>,
+    #[napi(js_name = "dcTitle")]
+    pub dc_title: Option<String>,
+    #[napi(js_name = "dcCreator")]
+    pub dc_creator: Option<String>,
+    #[napi(js_name = "dcSubject")]
+    pub dc_subject: Option<String>,
+    #[napi(js_name = "dcDescription")]
+    pub dc_description: Option<String>,
+    #[napi(js_name = "dcPublisher")]
+    pub dc_publisher: Option<String>,
+    #[napi(js_name = "dcDate")]
+    pub dc_date: Option<String>,
+    #[napi(js_name = "dcType")]
+    pub dc_type: Option<String>,
+    #[napi(js_name = "dcFormat")]
+    pub dc_format: Option<String>,
+    #[napi(js_name = "dcIdentifier")]
+    pub dc_identifier: Option<String>,
+    #[napi(js_name = "dcLanguage")]
+    pub dc_language: Option<String>,
+    #[napi(js_name = "dcRights")]
+    pub dc_rights: Option<String>,
+    pub article: Option<JsArticleMetadata>,
+    pub hreflangs: Option<Vec<JsHreflangEntry>>,
+    pub favicons: Option<Vec<JsFaviconInfo>>,
+    pub headings: Option<Vec<JsHeadingInfo>>,
+    #[napi(js_name = "wordCount")]
+    pub word_count: Option<i64>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsCitationResult {
+    pub content: Option<String>,
+    pub references: Option<Vec<JsCitationReference>>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsCitationReference {
+    pub index: Option<i64>,
+    pub url: Option<String>,
+    pub text: Option<String>,
+}
+
+#[derive(Clone)]
+#[napi]
+pub struct JsCrawlEngineHandle {
+    inner: Arc<kreuzcrawl::CrawlEngineHandle>,
+}
+
+#[napi]
+impl JsCrawlEngineHandle {}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsBatchScrapeResult {
+    pub url: Option<String>,
+    pub result: Option<JsScrapeResult>,
+    pub error: Option<String>,
+}
+
+#[derive(Clone, Default)]
+#[napi(object)]
+pub struct JsBatchCrawlResult {
+    pub url: Option<String>,
+    pub result: Option<JsCrawlResult>,
+    pub error: Option<String>,
+}
+
+#[napi(string_enum = "snake_case")]
+#[derive(Clone)]
+pub enum JsBrowserMode {
+    Auto,
+    Always,
+    Never,
+}
+
+#[allow(clippy::derivable_impls)]
+impl Default for JsBrowserMode {
+    fn default() -> Self {
+        Self::Auto
+    }
+}
+
+#[napi(string_enum = "snake_case")]
+#[derive(Clone)]
+pub enum JsBrowserWait {
+    NetworkIdle,
+    Selector,
+    Fixed,
+}
+
+#[allow(clippy::derivable_impls)]
+impl Default for JsBrowserWait {
+    fn default() -> Self {
+        Self::NetworkIdle
+    }
+}
+
+#[derive(Clone)]
+#[napi(object)]
+pub struct JsAuthConfig {
+    #[napi(js_name = "type")]
+    pub type_tag: String,
+    pub username: Option<String>,
+    pub password: Option<String>,
+    pub token: Option<String>,
+    pub name: Option<String>,
+    pub value: Option<String>,
+}
+
+#[allow(clippy::derivable_impls)]
+impl Default for JsAuthConfig {
+    fn default() -> Self {
+        Self {
+            type_tag: String::new(),
+            name: None,
+            password: None,
+            token: None,
+            username: None,
+            value: None,
+        }
+    }
+}
+
+#[napi(string_enum = "snake_case")]
+#[derive(Clone)]
+pub enum JsLinkType {
+    Internal,
+    External,
+    Anchor,
+    Document,
+}
+
+#[allow(clippy::derivable_impls)]
+impl Default for JsLinkType {
+    fn default() -> Self {
+        Self::Internal
+    }
+}
+
+#[napi(string_enum = "snake_case")]
+#[derive(Clone)]
+pub enum JsImageSource {
+    Img,
+    PictureSource,
+    OgImage,
+    TwitterImage,
+}
+
+#[allow(clippy::derivable_impls)]
+impl Default for JsImageSource {
+    fn default() -> Self {
+        Self::Img
+    }
+}
+
+#[napi(string_enum = "snake_case")]
+#[derive(Clone)]
+pub enum JsFeedType {
+    Rss,
+    Atom,
+    JsonFeed,
+}
+
+#[allow(clippy::derivable_impls)]
+impl Default for JsFeedType {
+    fn default() -> Self {
+        Self::Rss
+    }
+}
+
+#[napi(string_enum = "snake_case")]
+#[derive(Clone)]
+pub enum JsAssetCategory {
+    Document,
+    Image,
+    Audio,
+    Video,
+    Font,
+    Stylesheet,
+    Script,
+    Archive,
+    Data,
+    Other,
+}
+
+#[allow(clippy::derivable_impls)]
+impl Default for JsAssetCategory {
+    fn default() -> Self {
+        Self::Document
+    }
+}
+
+#[napi(string_enum)]
+#[derive(Clone)]
+pub enum JsCrawlEvent {
+    Page,
+    Error,
+    Complete,
+}
+
+#[allow(clippy::derivable_impls)]
+impl Default for JsCrawlEvent {
+    fn default() -> Self {
+        Self::Page
+    }
+}
+
+#[allow(clippy::missing_errors_doc)]
+#[napi(js_name = "createEngine")]
+pub fn create_engine(config: Option<JsCrawlConfig>) -> Result<JsCrawlEngineHandle> {
+    let config_core = config.map(Into::into);
+    kreuzcrawl::create_engine(config_core)
+        .map(|val| JsCrawlEngineHandle { inner: Arc::new(val) })
+        .map_err(|e| napi::Error::new(napi::Status::GenericFailure, e.to_string()))
+}
+
+#[allow(clippy::missing_errors_doc)]
+#[napi]
+pub async fn scrape(engine: &JsCrawlEngineHandle, url: String) -> Result<JsScrapeResult> {
+    let result = kreuzcrawl::scrape(&engine.inner, &url)
+        .await
+        .map_err(|e| napi::Error::new(napi::Status::GenericFailure, e.to_string()))?;
+    Ok(result.into())
+}
+
+#[allow(clippy::missing_errors_doc)]
+#[napi]
+pub async fn crawl(engine: &JsCrawlEngineHandle, url: String) -> Result<JsCrawlResult> {
+    let result = kreuzcrawl::crawl(&engine.inner, &url)
+        .await
+        .map_err(|e| napi::Error::new(napi::Status::GenericFailure, e.to_string()))?;
+    Ok(result.into())
+}
+
+#[allow(clippy::missing_errors_doc)]
+#[napi(js_name = "mapUrls")]
+pub async fn map_urls(engine: &JsCrawlEngineHandle, url: String) -> Result<JsMapResult> {
+    let result = kreuzcrawl::map_urls(&engine.inner, &url)
+        .await
+        .map_err(|e| napi::Error::new(napi::Status::GenericFailure, e.to_string()))?;
+    Ok(result.into())
+}
+
+#[napi(js_name = "batchScrape")]
+pub async fn batch_scrape(engine: &JsCrawlEngineHandle, urls: Vec<String>) -> Vec<JsBatchScrapeResult> {
+    let result = kreuzcrawl::batch_scrape(&engine.inner, urls).await;
+    result.into_iter().map(Into::into).collect()
+}
+
+#[napi(js_name = "batchCrawl")]
+pub async fn batch_crawl(engine: &JsCrawlEngineHandle, urls: Vec<String>) -> Vec<JsBatchCrawlResult> {
+    let result = kreuzcrawl::batch_crawl(&engine.inner, urls).await;
+    result.into_iter().map(Into::into).collect()
+}
+
+impl From<JsExtractionMeta> for kreuzcrawl::ExtractionMeta {
+    fn from(val: JsExtractionMeta) -> Self {
+        Self {
+            cost: val.cost,
+            prompt_tokens: val.prompt_tokens.map(|v| v as u64),
+            completion_tokens: val.completion_tokens.map(|v| v as u64),
+            model: val.model,
+            chunks_processed: val.chunks_processed.map(|v| v as usize).unwrap_or_default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::ExtractionMeta> for JsExtractionMeta {
+    fn from(val: kreuzcrawl::ExtractionMeta) -> Self {
+        Self {
+            cost: val.cost,
+            prompt_tokens: val.prompt_tokens.map(|v| v as i64),
+            completion_tokens: val.completion_tokens.map(|v| v as i64),
+            model: val.model,
+            chunks_processed: Some(val.chunks_processed as i64),
+        }
+    }
+}
+
+impl From<JsProxyConfig> for kreuzcrawl::ProxyConfig {
+    fn from(val: JsProxyConfig) -> Self {
+        Self {
+            url: val.url.unwrap_or_default(),
+            username: val.username,
+            password: val.password,
+        }
+    }
+}
+
+impl From<kreuzcrawl::ProxyConfig> for JsProxyConfig {
+    fn from(val: kreuzcrawl::ProxyConfig) -> Self {
+        Self {
+            url: Some(val.url),
+            username: val.username,
+            password: val.password,
+        }
+    }
+}
+
+#[allow(clippy::field_reassign_with_default)]
+impl From<JsBrowserConfig> for kreuzcrawl::BrowserConfig {
+    fn from(val: JsBrowserConfig) -> Self {
+        let mut __result = kreuzcrawl::BrowserConfig::default();
+        __result.mode = val.mode.map(Into::into).unwrap_or_default();
+        __result.endpoint = val.endpoint;
+        if let Some(__v) = val.timeout {
+            __result.timeout = std::time::Duration::from_millis(__v as u64);
+        }
+        __result.wait = val.wait.map(Into::into).unwrap_or_default();
+        __result.wait_selector = val.wait_selector;
+        __result.extra_wait = val.extra_wait.map(|v| std::time::Duration::from_millis(v as u64));
+        __result
+    }
+}
+
+impl From<kreuzcrawl::BrowserConfig> for JsBrowserConfig {
+    fn from(val: kreuzcrawl::BrowserConfig) -> Self {
+        Self {
+            mode: Some(val.mode.into()),
+            endpoint: val.endpoint,
+            timeout: Some(val.timeout.as_millis() as u64 as i64),
+            wait: Some(val.wait.into()),
+            wait_selector: val.wait_selector,
+            extra_wait: val.extra_wait.map(|d| d.as_millis() as u64 as i64),
+        }
+    }
+}
+
+#[allow(clippy::needless_update)]
+#[allow(clippy::field_reassign_with_default)]
+impl From<JsCrawlConfig> for kreuzcrawl::CrawlConfig {
+    fn from(val: JsCrawlConfig) -> Self {
+        let mut __result = kreuzcrawl::CrawlConfig::default();
+        __result.max_depth = val.max_depth.map(|v| v as usize);
+        __result.max_pages = val.max_pages.map(|v| v as usize);
+        __result.max_concurrent = val.max_concurrent.map(|v| v as usize);
+        __result.respect_robots_txt = val.respect_robots_txt.unwrap_or_default();
+        __result.user_agent = val.user_agent;
+        __result.stay_on_domain = val.stay_on_domain.unwrap_or_default();
+        __result.allow_subdomains = val.allow_subdomains.unwrap_or_default();
+        __result.include_paths = val.include_paths.unwrap_or_default();
+        __result.exclude_paths = val.exclude_paths.unwrap_or_default();
+        __result.custom_headers = val.custom_headers.unwrap_or_default().into_iter().collect();
+        if let Some(__v) = val.request_timeout {
+            __result.request_timeout = std::time::Duration::from_millis(__v as u64);
+        }
+        __result.max_redirects = val.max_redirects.map(|v| v as usize).unwrap_or_default();
+        __result.retry_count = val.retry_count.map(|v| v as usize).unwrap_or_default();
+        __result.retry_codes = val.retry_codes.unwrap_or_default();
+        __result.cookies_enabled = val.cookies_enabled.unwrap_or_default();
+        __result.auth = val.auth.map(Into::into);
+        __result.max_body_size = val.max_body_size.map(|v| v as usize);
+        __result.main_content_only = val.main_content_only.unwrap_or_default();
+        __result.remove_tags = val.remove_tags.unwrap_or_default();
+        __result.map_limit = val.map_limit.map(|v| v as usize);
+        __result.map_search = val.map_search;
+        __result.download_assets = val.download_assets.unwrap_or_default();
+        __result.asset_types = val
+            .asset_types
+            .map(|v| v.into_iter().map(Into::into).collect())
+            .unwrap_or_default();
+        __result.max_asset_size = val.max_asset_size.map(|v| v as usize);
+        __result.browser = val.browser.map(Into::into).unwrap_or_default();
+        __result.proxy = val.proxy.map(Into::into);
+        __result.user_agents = val.user_agents.unwrap_or_default();
+        __result.capture_screenshot = val.capture_screenshot.unwrap_or_default();
+        __result.download_documents = val.download_documents.unwrap_or_default();
+        __result.document_max_size = val.document_max_size.map(|v| v as usize);
+        __result.document_mime_types = val.document_mime_types.unwrap_or_default();
+        __result.warc_output = val.warc_output.map(Into::into);
+        __result.browser_profile = val.browser_profile;
+        __result.save_browser_profile = val.save_browser_profile.unwrap_or_default();
+        __result
+    }
+}
+
+impl From<kreuzcrawl::CrawlConfig> for JsCrawlConfig {
+    fn from(val: kreuzcrawl::CrawlConfig) -> Self {
+        Self {
+            max_depth: val.max_depth.map(|v| v as i64),
+            max_pages: val.max_pages.map(|v| v as i64),
+            max_concurrent: val.max_concurrent.map(|v| v as i64),
+            respect_robots_txt: Some(val.respect_robots_txt),
+            user_agent: val.user_agent,
+            stay_on_domain: Some(val.stay_on_domain),
+            allow_subdomains: Some(val.allow_subdomains),
+            include_paths: Some(val.include_paths),
+            exclude_paths: Some(val.exclude_paths),
+            custom_headers: Some(val.custom_headers.into_iter().collect()),
+            request_timeout: Some(val.request_timeout.as_millis() as u64 as i64),
+            max_redirects: Some(val.max_redirects as i64),
+            retry_count: Some(val.retry_count as i64),
+            retry_codes: Some(val.retry_codes),
+            cookies_enabled: Some(val.cookies_enabled),
+            auth: val.auth.map(Into::into),
+            max_body_size: val.max_body_size.map(|v| v as i64),
+            main_content_only: Some(val.main_content_only),
+            remove_tags: Some(val.remove_tags),
+            map_limit: val.map_limit.map(|v| v as i64),
+            map_search: val.map_search,
+            download_assets: Some(val.download_assets),
+            asset_types: Some(val.asset_types.into_iter().map(Into::into).collect()),
+            max_asset_size: val.max_asset_size.map(|v| v as i64),
+            browser: Some(val.browser.into()),
+            proxy: val.proxy.map(Into::into),
+            user_agents: Some(val.user_agents),
+            capture_screenshot: Some(val.capture_screenshot),
+            download_documents: Some(val.download_documents),
+            document_max_size: val.document_max_size.map(|v| v as i64),
+            document_mime_types: Some(val.document_mime_types),
+            warc_output: val.warc_output.map(|p| p.to_string_lossy().to_string()),
+            browser_profile: val.browser_profile,
+            save_browser_profile: Some(val.save_browser_profile),
+        }
+    }
+}
+
+impl From<JsDownloadedDocument> for kreuzcrawl::DownloadedDocument {
+    fn from(val: JsDownloadedDocument) -> Self {
+        Self {
+            url: val.url.unwrap_or_default(),
+            mime_type: Default::default(),
+            content: val.content.unwrap_or_default(),
+            size: val.size.map(|v| v as usize).unwrap_or_default(),
+            filename: Default::default(),
+            content_hash: Default::default(),
+            headers: Default::default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::DownloadedDocument> for JsDownloadedDocument {
+    fn from(val: kreuzcrawl::DownloadedDocument) -> Self {
+        Self {
+            url: Some(val.url),
+            mime_type: Some(format!("{:?}", val.mime_type)),
+            content: Some(val.content.to_vec()),
+            size: Some(val.size as i64),
+            filename: val.filename.as_ref().map(|v| format!("{:?}", v)),
+            content_hash: Some(format!("{:?}", val.content_hash)),
+            headers: Some(
+                val.headers
+                    .into_iter()
+                    .map(|(k, v)| (format!("{:?}", k), format!("{:?}", v)))
+                    .collect(),
+            ),
+        }
+    }
+}
+
+impl From<kreuzcrawl::InteractionResult> for JsInteractionResult {
+    fn from(val: kreuzcrawl::InteractionResult) -> Self {
+        Self {
+            action_results: Some(val.action_results.into_iter().map(Into::into).collect()),
+            final_html: Some(val.final_html),
+            final_url: Some(val.final_url),
+            screenshot: val.screenshot.map(|v| v.to_vec()),
+        }
+    }
+}
+
+impl From<kreuzcrawl::ActionResult> for JsActionResult {
+    fn from(val: kreuzcrawl::ActionResult) -> Self {
+        Self {
+            action_index: Some(val.action_index as i64),
+            action_type: Some(format!("{:?}", val.action_type)),
+            success: Some(val.success),
+            data: val.data.as_ref().map(ToString::to_string),
+            error: val.error,
+        }
+    }
+}
+
+impl From<JsScrapeResult> for kreuzcrawl::ScrapeResult {
+    fn from(val: JsScrapeResult) -> Self {
+        Self {
+            status_code: val.status_code.unwrap_or_default(),
+            content_type: val.content_type.unwrap_or_default(),
+            html: val.html.unwrap_or_default(),
+            body_size: val.body_size.map(|v| v as usize).unwrap_or_default(),
+            metadata: val.metadata.map(Into::into).unwrap_or_default(),
+            links: val
+                .links
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+            images: val
+                .images
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+            feeds: val
+                .feeds
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+            json_ld: val
+                .json_ld
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+            is_allowed: val.is_allowed.unwrap_or_default(),
+            crawl_delay: val.crawl_delay.map(|v| v as u64),
+            noindex_detected: val.noindex_detected.unwrap_or_default(),
+            nofollow_detected: val.nofollow_detected.unwrap_or_default(),
+            x_robots_tag: val.x_robots_tag,
+            is_pdf: val.is_pdf.unwrap_or_default(),
+            was_skipped: val.was_skipped.unwrap_or_default(),
+            detected_charset: val.detected_charset,
+            main_content_only: val.main_content_only.unwrap_or_default(),
+            auth_header_sent: val.auth_header_sent.unwrap_or_default(),
+            response_meta: val.response_meta.map(Into::into),
+            assets: val
+                .assets
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+            js_render_hint: val.js_render_hint.unwrap_or_default(),
+            browser_used: val.browser_used.unwrap_or_default(),
+            markdown: val.markdown.map(Into::into),
+            extracted_data: val.extracted_data.as_ref().and_then(|s| serde_json::from_str(s).ok()),
+            extraction_meta: val.extraction_meta.map(Into::into),
+            screenshot: val.screenshot,
+            downloaded_document: val.downloaded_document.map(Into::into),
+        }
+    }
+}
+
+impl From<kreuzcrawl::ScrapeResult> for JsScrapeResult {
+    fn from(val: kreuzcrawl::ScrapeResult) -> Self {
+        Self {
+            status_code: Some(val.status_code),
+            content_type: Some(val.content_type),
+            html: Some(val.html),
+            body_size: Some(val.body_size as i64),
+            metadata: Some(val.metadata.into()),
+            links: Some(val.links.into_iter().map(Into::into).collect()),
+            images: Some(val.images.into_iter().map(Into::into).collect()),
+            feeds: Some(val.feeds.into_iter().map(Into::into).collect()),
+            json_ld: Some(val.json_ld.into_iter().map(Into::into).collect()),
+            is_allowed: Some(val.is_allowed),
+            crawl_delay: val.crawl_delay.map(|v| v as i64),
+            noindex_detected: Some(val.noindex_detected),
+            nofollow_detected: Some(val.nofollow_detected),
+            x_robots_tag: val.x_robots_tag,
+            is_pdf: Some(val.is_pdf),
+            was_skipped: Some(val.was_skipped),
+            detected_charset: val.detected_charset,
+            main_content_only: Some(val.main_content_only),
+            auth_header_sent: Some(val.auth_header_sent),
+            response_meta: val.response_meta.map(Into::into),
+            assets: Some(val.assets.into_iter().map(Into::into).collect()),
+            js_render_hint: Some(val.js_render_hint),
+            browser_used: Some(val.browser_used),
+            markdown: val.markdown.map(Into::into),
+            extracted_data: val.extracted_data.as_ref().map(ToString::to_string),
+            extraction_meta: val.extraction_meta.map(Into::into),
+            screenshot: val.screenshot.map(|v| v.to_vec()),
+            downloaded_document: val.downloaded_document.map(Into::into),
+        }
+    }
+}
+
+impl From<JsCrawlPageResult> for kreuzcrawl::CrawlPageResult {
+    fn from(val: JsCrawlPageResult) -> Self {
+        Self {
+            url: val.url.unwrap_or_default(),
+            normalized_url: val.normalized_url.unwrap_or_default(),
+            status_code: val.status_code.unwrap_or_default(),
+            content_type: val.content_type.unwrap_or_default(),
+            html: val.html.unwrap_or_default(),
+            body_size: val.body_size.map(|v| v as usize).unwrap_or_default(),
+            metadata: val.metadata.map(Into::into).unwrap_or_default(),
+            links: val
+                .links
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+            images: val
+                .images
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+            feeds: val
+                .feeds
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+            json_ld: val
+                .json_ld
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+            depth: val.depth.map(|v| v as usize).unwrap_or_default(),
+            stayed_on_domain: val.stayed_on_domain.unwrap_or_default(),
+            was_skipped: val.was_skipped.unwrap_or_default(),
+            is_pdf: val.is_pdf.unwrap_or_default(),
+            detected_charset: val.detected_charset,
+            markdown: val.markdown.map(Into::into),
+            extracted_data: val.extracted_data.as_ref().and_then(|s| serde_json::from_str(s).ok()),
+            extraction_meta: val.extraction_meta.map(Into::into),
+            downloaded_document: val.downloaded_document.map(Into::into),
+        }
+    }
+}
+
+impl From<kreuzcrawl::CrawlPageResult> for JsCrawlPageResult {
+    fn from(val: kreuzcrawl::CrawlPageResult) -> Self {
+        Self {
+            url: Some(val.url),
+            normalized_url: Some(val.normalized_url),
+            status_code: Some(val.status_code),
+            content_type: Some(val.content_type),
+            html: Some(val.html),
+            body_size: Some(val.body_size as i64),
+            metadata: Some(val.metadata.into()),
+            links: Some(val.links.into_iter().map(Into::into).collect()),
+            images: Some(val.images.into_iter().map(Into::into).collect()),
+            feeds: Some(val.feeds.into_iter().map(Into::into).collect()),
+            json_ld: Some(val.json_ld.into_iter().map(Into::into).collect()),
+            depth: Some(val.depth as i64),
+            stayed_on_domain: Some(val.stayed_on_domain),
+            was_skipped: Some(val.was_skipped),
+            is_pdf: Some(val.is_pdf),
+            detected_charset: val.detected_charset,
+            markdown: val.markdown.map(Into::into),
+            extracted_data: val.extracted_data.as_ref().map(ToString::to_string),
+            extraction_meta: val.extraction_meta.map(Into::into),
+            downloaded_document: val.downloaded_document.map(Into::into),
+        }
+    }
+}
+
+impl From<JsCrawlResult> for kreuzcrawl::CrawlResult {
+    fn from(val: JsCrawlResult) -> Self {
+        Self {
+            pages: val
+                .pages
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+            final_url: val.final_url.unwrap_or_default(),
+            redirect_count: val.redirect_count.map(|v| v as usize).unwrap_or_default(),
+            was_skipped: val.was_skipped.unwrap_or_default(),
+            error: val.error,
+            cookies: val
+                .cookies
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+            normalized_urls: val.normalized_urls.unwrap_or_default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::CrawlResult> for JsCrawlResult {
+    fn from(val: kreuzcrawl::CrawlResult) -> Self {
+        Self {
+            pages: Some(val.pages.into_iter().map(Into::into).collect()),
+            final_url: Some(val.final_url),
+            redirect_count: Some(val.redirect_count as i64),
+            was_skipped: Some(val.was_skipped),
+            error: val.error,
+            cookies: Some(val.cookies.into_iter().map(Into::into).collect()),
+            normalized_urls: Some(val.normalized_urls),
+        }
+    }
+}
+
+impl From<JsSitemapUrl> for kreuzcrawl::SitemapUrl {
+    fn from(val: JsSitemapUrl) -> Self {
+        Self {
+            url: val.url.unwrap_or_default(),
+            lastmod: val.lastmod,
+            changefreq: val.changefreq,
+            priority: val.priority,
+        }
+    }
+}
+
+impl From<kreuzcrawl::SitemapUrl> for JsSitemapUrl {
+    fn from(val: kreuzcrawl::SitemapUrl) -> Self {
+        Self {
+            url: Some(val.url),
+            lastmod: val.lastmod,
+            changefreq: val.changefreq,
+            priority: val.priority,
+        }
+    }
+}
+
+impl From<JsMapResult> for kreuzcrawl::MapResult {
+    fn from(val: JsMapResult) -> Self {
+        Self {
+            urls: val
+                .urls
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::MapResult> for JsMapResult {
+    fn from(val: kreuzcrawl::MapResult) -> Self {
+        Self {
+            urls: Some(val.urls.into_iter().map(Into::into).collect()),
+        }
+    }
+}
+
+impl From<JsMarkdownResult> for kreuzcrawl::MarkdownResult {
+    fn from(val: JsMarkdownResult) -> Self {
+        Self {
+            content: val.content.unwrap_or_default(),
+            document_structure: val
+                .document_structure
+                .as_ref()
+                .and_then(|s| serde_json::from_str(s).ok()),
+            tables: val
+                .tables
+                .map(|v| v.into_iter().filter_map(|s| serde_json::from_str(&s).ok()).collect())
+                .unwrap_or_default(),
+            warnings: val.warnings.unwrap_or_default(),
+            citations: val.citations.map(Into::into),
+            fit_content: val.fit_content,
+        }
+    }
+}
+
+impl From<kreuzcrawl::MarkdownResult> for JsMarkdownResult {
+    fn from(val: kreuzcrawl::MarkdownResult) -> Self {
+        Self {
+            content: Some(val.content),
+            document_structure: val.document_structure.as_ref().map(ToString::to_string),
+            tables: Some(val.tables.iter().map(ToString::to_string).collect()),
+            warnings: Some(val.warnings),
+            citations: val.citations.map(Into::into),
+            fit_content: val.fit_content,
+        }
+    }
+}
+
+impl From<kreuzcrawl::CachedPage> for JsCachedPage {
+    fn from(val: kreuzcrawl::CachedPage) -> Self {
+        Self {
+            url: Some(val.url),
+            status_code: Some(val.status_code),
+            content_type: Some(val.content_type),
+            body: Some(val.body),
+            etag: val.etag,
+            last_modified: val.last_modified,
+            cached_at: Some(val.cached_at as i64),
+        }
+    }
+}
+
+impl From<JsLinkInfo> for kreuzcrawl::LinkInfo {
+    fn from(val: JsLinkInfo) -> Self {
+        Self {
+            url: val.url.unwrap_or_default(),
+            text: val.text.unwrap_or_default(),
+            link_type: val.link_type.map(Into::into).unwrap_or_default(),
+            rel: val.rel,
+            nofollow: val.nofollow.unwrap_or_default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::LinkInfo> for JsLinkInfo {
+    fn from(val: kreuzcrawl::LinkInfo) -> Self {
+        Self {
+            url: Some(val.url),
+            text: Some(val.text),
+            link_type: Some(val.link_type.into()),
+            rel: val.rel,
+            nofollow: Some(val.nofollow),
+        }
+    }
+}
+
+impl From<JsImageInfo> for kreuzcrawl::ImageInfo {
+    fn from(val: JsImageInfo) -> Self {
+        Self {
+            url: val.url.unwrap_or_default(),
+            alt: val.alt,
+            width: val.width,
+            height: val.height,
+            source: val.source.map(Into::into).unwrap_or_default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::ImageInfo> for JsImageInfo {
+    fn from(val: kreuzcrawl::ImageInfo) -> Self {
+        Self {
+            url: Some(val.url),
+            alt: val.alt,
+            width: val.width,
+            height: val.height,
+            source: Some(val.source.into()),
+        }
+    }
+}
+
+impl From<JsFeedInfo> for kreuzcrawl::FeedInfo {
+    fn from(val: JsFeedInfo) -> Self {
+        Self {
+            url: val.url.unwrap_or_default(),
+            title: val.title,
+            feed_type: val.feed_type.map(Into::into).unwrap_or_default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::FeedInfo> for JsFeedInfo {
+    fn from(val: kreuzcrawl::FeedInfo) -> Self {
+        Self {
+            url: Some(val.url),
+            title: val.title,
+            feed_type: Some(val.feed_type.into()),
+        }
+    }
+}
+
+impl From<JsJsonLdEntry> for kreuzcrawl::JsonLdEntry {
+    fn from(val: JsJsonLdEntry) -> Self {
+        Self {
+            schema_type: val.schema_type.unwrap_or_default(),
+            name: val.name,
+            raw: val.raw.unwrap_or_default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::JsonLdEntry> for JsJsonLdEntry {
+    fn from(val: kreuzcrawl::JsonLdEntry) -> Self {
+        Self {
+            schema_type: Some(val.schema_type),
+            name: val.name,
+            raw: Some(val.raw),
+        }
+    }
+}
+
+impl From<JsCookieInfo> for kreuzcrawl::CookieInfo {
+    fn from(val: JsCookieInfo) -> Self {
+        Self {
+            name: val.name.unwrap_or_default(),
+            value: val.value.unwrap_or_default(),
+            domain: val.domain,
+            path: val.path,
+        }
+    }
+}
+
+impl From<kreuzcrawl::CookieInfo> for JsCookieInfo {
+    fn from(val: kreuzcrawl::CookieInfo) -> Self {
+        Self {
+            name: Some(val.name),
+            value: Some(val.value),
+            domain: val.domain,
+            path: val.path,
+        }
+    }
+}
+
+impl From<JsDownloadedAsset> for kreuzcrawl::DownloadedAsset {
+    fn from(val: JsDownloadedAsset) -> Self {
+        Self {
+            url: val.url.unwrap_or_default(),
+            content_hash: val.content_hash.unwrap_or_default(),
+            mime_type: val.mime_type,
+            size: val.size.map(|v| v as usize).unwrap_or_default(),
+            asset_category: val.asset_category.map(Into::into).unwrap_or_default(),
+            html_tag: val.html_tag,
+        }
+    }
+}
+
+impl From<kreuzcrawl::DownloadedAsset> for JsDownloadedAsset {
+    fn from(val: kreuzcrawl::DownloadedAsset) -> Self {
+        Self {
+            url: Some(val.url),
+            content_hash: Some(val.content_hash),
+            mime_type: val.mime_type,
+            size: Some(val.size as i64),
+            asset_category: Some(val.asset_category.into()),
+            html_tag: val.html_tag,
+        }
+    }
+}
+
+impl From<JsArticleMetadata> for kreuzcrawl::ArticleMetadata {
+    fn from(val: JsArticleMetadata) -> Self {
+        Self {
+            published_time: val.published_time,
+            modified_time: val.modified_time,
+            author: val.author,
+            section: val.section,
+            tags: val.tags.unwrap_or_default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::ArticleMetadata> for JsArticleMetadata {
+    fn from(val: kreuzcrawl::ArticleMetadata) -> Self {
+        Self {
+            published_time: val.published_time,
+            modified_time: val.modified_time,
+            author: val.author,
+            section: val.section,
+            tags: Some(val.tags),
+        }
+    }
+}
+
+impl From<JsHreflangEntry> for kreuzcrawl::HreflangEntry {
+    fn from(val: JsHreflangEntry) -> Self {
+        Self {
+            lang: val.lang.unwrap_or_default(),
+            url: val.url.unwrap_or_default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::HreflangEntry> for JsHreflangEntry {
+    fn from(val: kreuzcrawl::HreflangEntry) -> Self {
+        Self {
+            lang: Some(val.lang),
+            url: Some(val.url),
+        }
+    }
+}
+
+impl From<JsFaviconInfo> for kreuzcrawl::FaviconInfo {
+    fn from(val: JsFaviconInfo) -> Self {
+        Self {
+            url: val.url.unwrap_or_default(),
+            rel: val.rel.unwrap_or_default(),
+            sizes: val.sizes,
+            mime_type: val.mime_type,
+        }
+    }
+}
+
+impl From<kreuzcrawl::FaviconInfo> for JsFaviconInfo {
+    fn from(val: kreuzcrawl::FaviconInfo) -> Self {
+        Self {
+            url: Some(val.url),
+            rel: Some(val.rel),
+            sizes: val.sizes,
+            mime_type: val.mime_type,
+        }
+    }
+}
+
+impl From<JsHeadingInfo> for kreuzcrawl::HeadingInfo {
+    fn from(val: JsHeadingInfo) -> Self {
+        Self {
+            level: val.level.unwrap_or_default(),
+            text: val.text.unwrap_or_default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::HeadingInfo> for JsHeadingInfo {
+    fn from(val: kreuzcrawl::HeadingInfo) -> Self {
+        Self {
+            level: Some(val.level),
+            text: Some(val.text),
+        }
+    }
+}
+
+impl From<JsResponseMeta> for kreuzcrawl::ResponseMeta {
+    fn from(val: JsResponseMeta) -> Self {
+        Self {
+            etag: val.etag,
+            last_modified: val.last_modified,
+            cache_control: val.cache_control,
+            server: val.server,
+            x_powered_by: val.x_powered_by,
+            content_language: val.content_language,
+            content_encoding: val.content_encoding,
+        }
+    }
+}
+
+impl From<kreuzcrawl::ResponseMeta> for JsResponseMeta {
+    fn from(val: kreuzcrawl::ResponseMeta) -> Self {
+        Self {
+            etag: val.etag,
+            last_modified: val.last_modified,
+            cache_control: val.cache_control,
+            server: val.server,
+            x_powered_by: val.x_powered_by,
+            content_language: val.content_language,
+            content_encoding: val.content_encoding,
+        }
+    }
+}
+
+impl From<JsPageMetadata> for kreuzcrawl::PageMetadata {
+    fn from(val: JsPageMetadata) -> Self {
+        Self {
+            title: val.title,
+            description: val.description,
+            canonical_url: val.canonical_url,
+            keywords: val.keywords,
+            author: val.author,
+            viewport: val.viewport,
+            theme_color: val.theme_color,
+            generator: val.generator,
+            robots: val.robots,
+            html_lang: val.html_lang,
+            html_dir: val.html_dir,
+            og_title: val.og_title,
+            og_type: val.og_type,
+            og_image: val.og_image,
+            og_description: val.og_description,
+            og_url: val.og_url,
+            og_site_name: val.og_site_name,
+            og_locale: val.og_locale,
+            og_video: val.og_video,
+            og_audio: val.og_audio,
+            og_locale_alternates: val.og_locale_alternates,
+            twitter_card: val.twitter_card,
+            twitter_title: val.twitter_title,
+            twitter_description: val.twitter_description,
+            twitter_image: val.twitter_image,
+            twitter_site: val.twitter_site,
+            twitter_creator: val.twitter_creator,
+            dc_title: val.dc_title,
+            dc_creator: val.dc_creator,
+            dc_subject: val.dc_subject,
+            dc_description: val.dc_description,
+            dc_publisher: val.dc_publisher,
+            dc_date: val.dc_date,
+            dc_type: val.dc_type,
+            dc_format: val.dc_format,
+            dc_identifier: val.dc_identifier,
+            dc_language: val.dc_language,
+            dc_rights: val.dc_rights,
+            article: val.article.map(Into::into),
+            hreflangs: val.hreflangs.map(|v| v.into_iter().map(Into::into).collect()),
+            favicons: val.favicons.map(|v| v.into_iter().map(Into::into).collect()),
+            headings: val.headings.map(|v| v.into_iter().map(Into::into).collect()),
+            word_count: val.word_count.map(|v| v as usize),
+        }
+    }
+}
+
+impl From<kreuzcrawl::PageMetadata> for JsPageMetadata {
+    fn from(val: kreuzcrawl::PageMetadata) -> Self {
+        Self {
+            title: val.title,
+            description: val.description,
+            canonical_url: val.canonical_url,
+            keywords: val.keywords,
+            author: val.author,
+            viewport: val.viewport,
+            theme_color: val.theme_color,
+            generator: val.generator,
+            robots: val.robots,
+            html_lang: val.html_lang,
+            html_dir: val.html_dir,
+            og_title: val.og_title,
+            og_type: val.og_type,
+            og_image: val.og_image,
+            og_description: val.og_description,
+            og_url: val.og_url,
+            og_site_name: val.og_site_name,
+            og_locale: val.og_locale,
+            og_video: val.og_video,
+            og_audio: val.og_audio,
+            og_locale_alternates: val.og_locale_alternates,
+            twitter_card: val.twitter_card,
+            twitter_title: val.twitter_title,
+            twitter_description: val.twitter_description,
+            twitter_image: val.twitter_image,
+            twitter_site: val.twitter_site,
+            twitter_creator: val.twitter_creator,
+            dc_title: val.dc_title,
+            dc_creator: val.dc_creator,
+            dc_subject: val.dc_subject,
+            dc_description: val.dc_description,
+            dc_publisher: val.dc_publisher,
+            dc_date: val.dc_date,
+            dc_type: val.dc_type,
+            dc_format: val.dc_format,
+            dc_identifier: val.dc_identifier,
+            dc_language: val.dc_language,
+            dc_rights: val.dc_rights,
+            article: val.article.map(Into::into),
+            hreflangs: val.hreflangs.map(|v| v.into_iter().map(Into::into).collect()),
+            favicons: val.favicons.map(|v| v.into_iter().map(Into::into).collect()),
+            headings: val.headings.map(|v| v.into_iter().map(Into::into).collect()),
+            word_count: val.word_count.map(|v| v as i64),
+        }
+    }
+}
+
+impl From<JsCitationResult> for kreuzcrawl::CitationResult {
+    fn from(val: JsCitationResult) -> Self {
+        Self {
+            content: val.content.unwrap_or_default(),
+            references: val
+                .references
+                .map(|v| v.into_iter().map(Into::into).collect())
+                .unwrap_or_default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::CitationResult> for JsCitationResult {
+    fn from(val: kreuzcrawl::CitationResult) -> Self {
+        Self {
+            content: Some(val.content),
+            references: Some(val.references.into_iter().map(Into::into).collect()),
+        }
+    }
+}
+
+impl From<JsCitationReference> for kreuzcrawl::CitationReference {
+    fn from(val: JsCitationReference) -> Self {
+        Self {
+            index: val.index.map(|v| v as usize).unwrap_or_default(),
+            url: val.url.unwrap_or_default(),
+            text: val.text.unwrap_or_default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::CitationReference> for JsCitationReference {
+    fn from(val: kreuzcrawl::CitationReference) -> Self {
+        Self {
+            index: Some(val.index as i64),
+            url: Some(val.url),
+            text: Some(val.text),
+        }
+    }
+}
+
+impl From<JsBatchScrapeResult> for kreuzcrawl::BatchScrapeResult {
+    fn from(val: JsBatchScrapeResult) -> Self {
+        Self {
+            url: val.url.unwrap_or_default(),
+            result: val.result.map(Into::into),
+            error: val.error,
+        }
+    }
+}
+
+impl From<kreuzcrawl::BatchScrapeResult> for JsBatchScrapeResult {
+    fn from(val: kreuzcrawl::BatchScrapeResult) -> Self {
+        Self {
+            url: Some(val.url),
+            result: val.result.map(Into::into),
+            error: val.error,
+        }
+    }
+}
+
+impl From<JsBatchCrawlResult> for kreuzcrawl::BatchCrawlResult {
+    fn from(val: JsBatchCrawlResult) -> Self {
+        Self {
+            url: val.url.unwrap_or_default(),
+            result: val.result.map(Into::into),
+            error: val.error,
+        }
+    }
+}
+
+impl From<kreuzcrawl::BatchCrawlResult> for JsBatchCrawlResult {
+    fn from(val: kreuzcrawl::BatchCrawlResult) -> Self {
+        Self {
+            url: Some(val.url),
+            result: val.result.map(Into::into),
+            error: val.error,
+        }
+    }
+}
+
+impl From<JsBrowserMode> for kreuzcrawl::BrowserMode {
+    fn from(val: JsBrowserMode) -> Self {
+        match val {
+            JsBrowserMode::Auto => Self::Auto,
+            JsBrowserMode::Always => Self::Always,
+            JsBrowserMode::Never => Self::Never,
+        }
+    }
+}
+
+impl From<kreuzcrawl::BrowserMode> for JsBrowserMode {
+    fn from(val: kreuzcrawl::BrowserMode) -> Self {
+        match val {
+            kreuzcrawl::BrowserMode::Auto => Self::Auto,
+            kreuzcrawl::BrowserMode::Always => Self::Always,
+            kreuzcrawl::BrowserMode::Never => Self::Never,
+        }
+    }
+}
+
+impl From<JsBrowserWait> for kreuzcrawl::BrowserWait {
+    fn from(val: JsBrowserWait) -> Self {
+        match val {
+            JsBrowserWait::NetworkIdle => Self::NetworkIdle,
+            JsBrowserWait::Selector => Self::Selector,
+            JsBrowserWait::Fixed => Self::Fixed,
+        }
+    }
+}
+
+impl From<kreuzcrawl::BrowserWait> for JsBrowserWait {
+    fn from(val: kreuzcrawl::BrowserWait) -> Self {
+        match val {
+            kreuzcrawl::BrowserWait::NetworkIdle => Self::NetworkIdle,
+            kreuzcrawl::BrowserWait::Selector => Self::Selector,
+            kreuzcrawl::BrowserWait::Fixed => Self::Fixed,
+        }
+    }
+}
+
+impl From<JsAuthConfig> for kreuzcrawl::AuthConfig {
+    fn from(val: JsAuthConfig) -> Self {
+        match val.type_tag.as_str() {
+            "basic" => Self::Basic {
+                username: val.username.unwrap_or_default(),
+                password: val.password.unwrap_or_default(),
+            },
+            "bearer" => Self::Bearer {
+                token: val.token.unwrap_or_default(),
+            },
+            "header" => Self::Header {
+                name: val.name.unwrap_or_default(),
+                value: val.value.unwrap_or_default(),
+            },
+            _ => Self::Basic {
+                username: Default::default(),
+                password: Default::default(),
+            },
+        }
+    }
+}
+
+impl From<kreuzcrawl::AuthConfig> for JsAuthConfig {
+    fn from(val: kreuzcrawl::AuthConfig) -> Self {
+        match val {
+            kreuzcrawl::AuthConfig::Basic { username, password } => Self {
+                type_tag: "basic".to_string(),
+                name: None,
+                password: Some(password),
+                token: None,
+                username: Some(username),
+                value: None,
+            },
+            kreuzcrawl::AuthConfig::Bearer { token } => Self {
+                type_tag: "bearer".to_string(),
+                name: None,
+                password: None,
+                token: Some(token),
+                username: None,
+                value: None,
+            },
+            kreuzcrawl::AuthConfig::Header { name, value } => Self {
+                type_tag: "header".to_string(),
+                name: Some(name),
+                password: None,
+                token: None,
+                username: None,
+                value: Some(value),
+            },
+        }
+    }
+}
+
+impl From<JsLinkType> for kreuzcrawl::LinkType {
+    fn from(val: JsLinkType) -> Self {
+        match val {
+            JsLinkType::Internal => Self::Internal,
+            JsLinkType::External => Self::External,
+            JsLinkType::Anchor => Self::Anchor,
+            JsLinkType::Document => Self::Document,
+        }
+    }
+}
+
+impl From<kreuzcrawl::LinkType> for JsLinkType {
+    fn from(val: kreuzcrawl::LinkType) -> Self {
+        match val {
+            kreuzcrawl::LinkType::Internal => Self::Internal,
+            kreuzcrawl::LinkType::External => Self::External,
+            kreuzcrawl::LinkType::Anchor => Self::Anchor,
+            kreuzcrawl::LinkType::Document => Self::Document,
+        }
+    }
+}
+
+impl From<JsImageSource> for kreuzcrawl::ImageSource {
+    fn from(val: JsImageSource) -> Self {
+        match val {
+            JsImageSource::Img => Self::Img,
+            JsImageSource::PictureSource => Self::PictureSource,
+            JsImageSource::OgImage => Self::OgImage,
+            JsImageSource::TwitterImage => Self::TwitterImage,
+        }
+    }
+}
+
+impl From<kreuzcrawl::ImageSource> for JsImageSource {
+    fn from(val: kreuzcrawl::ImageSource) -> Self {
+        match val {
+            kreuzcrawl::ImageSource::Img => Self::Img,
+            kreuzcrawl::ImageSource::PictureSource => Self::PictureSource,
+            kreuzcrawl::ImageSource::OgImage => Self::OgImage,
+            kreuzcrawl::ImageSource::TwitterImage => Self::TwitterImage,
+        }
+    }
+}
+
+impl From<JsFeedType> for kreuzcrawl::FeedType {
+    fn from(val: JsFeedType) -> Self {
+        match val {
+            JsFeedType::Rss => Self::Rss,
+            JsFeedType::Atom => Self::Atom,
+            JsFeedType::JsonFeed => Self::JsonFeed,
+        }
+    }
+}
+
+impl From<kreuzcrawl::FeedType> for JsFeedType {
+    fn from(val: kreuzcrawl::FeedType) -> Self {
+        match val {
+            kreuzcrawl::FeedType::Rss => Self::Rss,
+            kreuzcrawl::FeedType::Atom => Self::Atom,
+            kreuzcrawl::FeedType::JsonFeed => Self::JsonFeed,
+        }
+    }
+}
+
+impl From<JsAssetCategory> for kreuzcrawl::AssetCategory {
+    fn from(val: JsAssetCategory) -> Self {
+        match val {
+            JsAssetCategory::Document => Self::Document,
+            JsAssetCategory::Image => Self::Image,
+            JsAssetCategory::Audio => Self::Audio,
+            JsAssetCategory::Video => Self::Video,
+            JsAssetCategory::Font => Self::Font,
+            JsAssetCategory::Stylesheet => Self::Stylesheet,
+            JsAssetCategory::Script => Self::Script,
+            JsAssetCategory::Archive => Self::Archive,
+            JsAssetCategory::Data => Self::Data,
+            JsAssetCategory::Other => Self::Other,
+        }
+    }
+}
+
+impl From<kreuzcrawl::AssetCategory> for JsAssetCategory {
+    fn from(val: kreuzcrawl::AssetCategory) -> Self {
+        match val {
+            kreuzcrawl::AssetCategory::Document => Self::Document,
+            kreuzcrawl::AssetCategory::Image => Self::Image,
+            kreuzcrawl::AssetCategory::Audio => Self::Audio,
+            kreuzcrawl::AssetCategory::Video => Self::Video,
+            kreuzcrawl::AssetCategory::Font => Self::Font,
+            kreuzcrawl::AssetCategory::Stylesheet => Self::Stylesheet,
+            kreuzcrawl::AssetCategory::Script => Self::Script,
+            kreuzcrawl::AssetCategory::Archive => Self::Archive,
+            kreuzcrawl::AssetCategory::Data => Self::Data,
+            kreuzcrawl::AssetCategory::Other => Self::Other,
+        }
+    }
+}
+
+impl From<kreuzcrawl::CrawlEvent> for JsCrawlEvent {
+    fn from(val: kreuzcrawl::CrawlEvent) -> Self {
+        match val {
+            kreuzcrawl::CrawlEvent::Page(..) => Self::Page,
+            kreuzcrawl::CrawlEvent::Error { .. } => Self::Error,
+            kreuzcrawl::CrawlEvent::Complete { .. } => Self::Complete,
+        }
+    }
+}
+
+// Error variant name constants
+pub const CRAWL_ERROR_ERROR_NOT_FOUND: &str = "NotFound";
+pub const CRAWL_ERROR_ERROR_UNAUTHORIZED: &str = "Unauthorized";
+pub const CRAWL_ERROR_ERROR_FORBIDDEN: &str = "Forbidden";
+pub const CRAWL_ERROR_ERROR_WAF_BLOCKED: &str = "WafBlocked";
+pub const CRAWL_ERROR_ERROR_TIMEOUT: &str = "Timeout";
+pub const CRAWL_ERROR_ERROR_RATE_LIMITED: &str = "RateLimited";
+pub const CRAWL_ERROR_ERROR_SERVER_ERROR: &str = "ServerError";
+pub const CRAWL_ERROR_ERROR_BAD_GATEWAY: &str = "BadGateway";
+pub const CRAWL_ERROR_ERROR_GONE: &str = "Gone";
+pub const CRAWL_ERROR_ERROR_CONNECTION: &str = "Connection";
+pub const CRAWL_ERROR_ERROR_DNS: &str = "Dns";
+pub const CRAWL_ERROR_ERROR_SSL: &str = "Ssl";
+pub const CRAWL_ERROR_ERROR_DATA_LOSS: &str = "DataLoss";
+pub const CRAWL_ERROR_ERROR_BROWSER_ERROR: &str = "BrowserError";
+pub const CRAWL_ERROR_ERROR_BROWSER_TIMEOUT: &str = "BrowserTimeout";
+pub const CRAWL_ERROR_ERROR_INVALID_CONFIG: &str = "InvalidConfig";
+pub const CRAWL_ERROR_ERROR_OTHER: &str = "Other";
+
+/// Convert a `kreuzcrawl::CrawlError` error to a NAPI error.
+#[allow(dead_code)]
+fn crawl_error_to_napi_err(e: kreuzcrawl::CrawlError) -> napi::Error {
+    let msg = e.to_string();
+    #[allow(unreachable_patterns)]
+    match &e {
+        kreuzcrawl::CrawlError::NotFound(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[NotFound] {}", msg))
+        }
+        kreuzcrawl::CrawlError::Unauthorized(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[Unauthorized] {}", msg))
+        }
+        kreuzcrawl::CrawlError::Forbidden(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[Forbidden] {}", msg))
+        }
+        kreuzcrawl::CrawlError::WafBlocked(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[WafBlocked] {}", msg))
+        }
+        kreuzcrawl::CrawlError::Timeout(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[Timeout] {}", msg))
+        }
+        kreuzcrawl::CrawlError::RateLimited(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[RateLimited] {}", msg))
+        }
+        kreuzcrawl::CrawlError::ServerError(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[ServerError] {}", msg))
+        }
+        kreuzcrawl::CrawlError::BadGateway(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[BadGateway] {}", msg))
+        }
+        kreuzcrawl::CrawlError::Gone(..) => napi::Error::new(napi::Status::GenericFailure, format!("[Gone] {}", msg)),
+        kreuzcrawl::CrawlError::Connection(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[Connection] {}", msg))
+        }
+        kreuzcrawl::CrawlError::Dns(..) => napi::Error::new(napi::Status::GenericFailure, format!("[Dns] {}", msg)),
+        kreuzcrawl::CrawlError::Ssl(..) => napi::Error::new(napi::Status::GenericFailure, format!("[Ssl] {}", msg)),
+        kreuzcrawl::CrawlError::DataLoss(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[DataLoss] {}", msg))
+        }
+        kreuzcrawl::CrawlError::BrowserError(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[BrowserError] {}", msg))
+        }
+        kreuzcrawl::CrawlError::BrowserTimeout(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[BrowserTimeout] {}", msg))
+        }
+        kreuzcrawl::CrawlError::InvalidConfig(..) => {
+            napi::Error::new(napi::Status::GenericFailure, format!("[InvalidConfig] {}", msg))
+        }
+        kreuzcrawl::CrawlError::Other(..) => napi::Error::new(napi::Status::GenericFailure, format!("[Other] {}", msg)),
+        _ => napi::Error::new(napi::Status::GenericFailure, msg),
+    }
+}