recker 1.0.43 → 1.0.44

package/dist/seo/rules/types.d.ts

@@ -3,6 +3,23 @@ import type { ExtractedLink } from '../../scrape/types.js';
 export type RuleSeverity = 'error' | 'warning' | 'info';
 export type RuleCategory = 'title' | 'meta' | 'og' | 'twitter' | 'headings' | 'images' | 'links' | 'content' | 'technical' | 'security' | 'mobile' | 'structured-data' | 'performance' | 'accessibility' | 'ai-search' | 'resources' | 'crawlability' | 'canonicalization';
 export interface RuleContext {
+    keywordsInTitle?: boolean;
+    keywordsInDescription?: boolean;
+    keywordsInH1?: boolean;
+    keywordsInUrl?: boolean;
+    keywordsInFirstParagraph?: boolean;
+    keywordsInAltText?: boolean;
+    keywordConsistencyScore?: number;
+    keywordConsistencyDetails?: {
+        inTitle: boolean;
+        inDescription: boolean;
+        inH1: boolean;
+        inUrl: boolean;
+        inFirstParagraph: boolean;
+        inAltText: boolean;
+    };
+    topKeywords?: string[];
+    mainKeyword?: string;
     title?: string;
     titleLength?: number;
     metaDescription?: string;
@@ -34,9 +51,12 @@ export interface RuleContext {
     imagesWithDimensions?: number;
     imagesMissingDimensions?: number;
     imagesWithEmptyAlt?: number;
+    imagesWithSrcset?: number;
+    largeBase64ImagesCount?: number;
     imagesDecorativeCount?: number;
     imagesUsingModernFormats?: number;
     altTextLengths?: number[];
+    imageAltTexts?: string[];
     imageFilenames?: string[];
     imagesWithAsyncDecoding?: number;
     brokenExternalImages?: number;
@@ -70,6 +90,8 @@ export interface RuleContext {
     totalLinks?: number;
     internalLinks?: number;
     externalLinks?: number;
+    internalHttpLinks?: number;
+    internalHttpLinkUrls?: string[];
     linksWithoutText?: number;
     nofollowLinks?: number;
     sponsoredLinks?: number;
@@ -89,6 +111,8 @@ export interface RuleContext {
         missingNoreferrer?: ExtractedLink[];
     };
     wordCount?: number;
+    emailsFound?: string[];
+    socialLinksFound?: string[];
     characterCount?: number;
     sentenceCount?: number;
     paragraphCount?: number;
@@ -102,7 +126,6 @@ export interface RuleContext {
     avgSentenceLength?: number;
     faqCount?: number;
     imagePerWordRatio?: number;
-    mainKeyword?: string;
     keywordDensity?: number;
     fleschReadingEase?: number;
     hasQuestionHeadings?: boolean;
@@ -120,6 +143,7 @@ export interface RuleContext {
     hasBreadcrumbsSchema?: boolean;
     videoCount?: number;
     audioCount?: number;
+    hasAutoplay?: boolean;
     hasCanonical?: boolean;
     canonicalUrl?: string;
     hasViewport?: boolean;
@@ -134,7 +158,10 @@ export interface RuleContext {
     textHtmlRatio?: number;
     hasDeprecatedPlugins?: boolean;
     deprecatedPluginTypes?: string[];
+    deprecatedTagsCount?: number;
+    deprecatedTagsFound?: string[];
     hasFrameTags?: boolean;
+    iframeCount?: number;
     hasFavicon?: boolean;
     faviconUrl?: string;
     hasPreconnect?: boolean;
@@ -321,6 +348,21 @@ export interface RuleContext {
     pinterestRichPinSupport?: boolean;
     hasPinterestNopin?: boolean;
     fbAppId?: string;
+    totalSocialLinks?: number;
+    socialLinksInHeader?: number;
+    socialLinksInFooter?: number;
+    socialLinksWithoutAccessibility?: number;
+    socialLinksWithoutNewTab?: number;
+    socialLinksWithoutNoopener?: number;
+    platformsFound?: string[];
+    socialLinkDetails?: Array<{
+        href: string;
+        platform: string;
+        hasAccessibility: boolean;
+        hasNewTab: boolean;
+        hasNoopener: boolean;
+        location: 'header' | 'footer' | 'body';
+    }>;
     navLinkCount?: number;
     footerLinkCount?: number;
     contextualLinkCount?: number;
@@ -408,6 +450,16 @@ export interface RuleContext {
     tlsVersion?: string;
     hasPasswordField?: boolean;
     formsOnHttp?: number;
+    analyticsDetected?: boolean;
+    analyticsProviders?: string[];
+    hasRssFeed?: boolean;
+    rssFeedUrl?: string;
+    hasAtomFeed?: boolean;
+    atomFeedUrl?: string;
+    ctaButtonsCount?: number;
+    formCount?: number;
+    hasWhatsAppLink?: boolean;
+    pageInSitemap?: boolean;
 }
 export interface RuleEvidence {
     found?: string | number | string[];

package/dist/seo/seo-spider.d.ts

@@ -1,5 +1,6 @@
 import { SpiderOptions, SpiderResult, SpiderPageResult } from '../scrape/spider.js';
 import type { SeoReport } from './types.js';
+import { type SitemapValidationResult } from './validators/sitemap.js';
 export interface SeoSpiderOptions extends SpiderOptions {
     seo?: boolean;
     output?: string;
@@ -20,6 +21,25 @@ export interface SiteWideIssue {
 export interface SeoSpiderResult extends Omit<SpiderResult, 'pages'> {
     pages: SeoPageResult[];
     siteWideIssues: SiteWideIssue[];
+    txtFiles?: {
+        humans: {
+            found: boolean;
+            content?: string;
+            url: string;
+        };
+        llms: {
+            found: boolean;
+            content?: string;
+            url: string;
+        };
+    };
+    rssFeeds?: Array<{
+        url: string;
+        type: 'rss' | 'atom' | 'unknown';
+        title?: string;
+        itemCount: number;
+    }>;
+    sitemapValidation?: SitemapValidationResult;
     summary: {
         totalPages: number;
         pagesWithErrors: number;
@@ -37,6 +57,8 @@ export declare class SeoSpider {
     private seoResults;
     constructor(options?: SeoSpiderOptions);
     crawl(startUrl: string): Promise<SeoSpiderResult>;
+    private checkTextFiles;
+    private validateSitemap;
     private analyzePages;
     private createReportFromPageData;
     private detectSiteWideIssues;

package/dist/seo/seo-spider.js

@@ -1,6 +1,8 @@
 import { Spider } from '../scrape/spider.js';
 import { analyzeSeo } from './analyzer.js';
 import { createClient } from '../core/client.js';
+import { discoverFeeds } from './validators/rss.js';
+import { fetchAndValidateSitemap } from './validators/sitemap.js';
 import * as fs from 'fs/promises';
 export class SeoSpider {
     spider;
@@ -32,10 +34,23 @@ export class SeoSpider {
         const seoPages = await this.analyzePages(result.pages);
         const siteWideIssues = this.detectSiteWideIssues(seoPages);
         const summary = this.calculateSummary(seoPages, siteWideIssues);
+        const txtFiles = await this.checkTextFiles(startUrl);
+        let homeHtml = '';
+        try {
+            const client = createClient({ timeout: 10000 });
+            const res = await client.get(startUrl);
+            homeHtml = await res.text();
+        }
+        catch { }
+        const rssFeeds = await discoverFeeds(new URL(startUrl).origin, homeHtml);
+        const sitemapValidation = await this.validateSitemap(startUrl);
         const seoResult = {
             ...result,
             pages: seoPages,
             siteWideIssues,
+            txtFiles,
+            rssFeeds,
+            sitemapValidation,
             summary,
         };
         if (this.options.output) {
@@ -43,6 +58,57 @@ export class SeoSpider {
         }
         return seoResult;
     }
+    async checkTextFiles(startUrl) {
+        try {
+            const baseUrl = new URL(startUrl).origin;
+            const client = createClient({ timeout: 5000 });
+            const results = {
+                humans: { found: false, content: undefined, url: `${baseUrl}/humans.txt` },
+                llms: { found: false, content: undefined, url: `${baseUrl}/llms.txt` },
+            };
+            try {
+                const res = await client.get(results.humans.url);
+                if (res.status === 200) {
+                    results.humans.found = true;
+                    results.humans.content = await res.text();
+                }
+            }
+            catch { }
+            try {
+                const res = await client.get(results.llms.url);
+                if (res.status === 200) {
+                    results.llms.found = true;
+                    results.llms.content = await res.text();
+                }
+            }
+            catch { }
+            return results;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async validateSitemap(startUrl) {
+        try {
+            const baseUrl = new URL(startUrl).origin;
+            const sitemapUrl = `${baseUrl}/sitemap.xml`;
+            const client = createClient({ timeout: this.options.timeout || 15000 });
+            const fetcher = async (url) => {
+                const res = await client.get(url);
+                const text = await res.text();
+                return {
+                    status: res.status,
+                    text,
+                    headers: Object.fromEntries([...res.headers.entries()]),
+                };
+            };
+            const result = await fetchAndValidateSitemap(sitemapUrl, fetcher);
+            return result;
+        }
+        catch {
+            return undefined;
+        }
+    }
     async analyzePages(pages) {
         const results = [];
         const client = createClient({
@@ -93,8 +159,9 @@ export class SeoSpider {
             if (titleLength < 30) {
                 checks.push({
                     name: 'Title Length',
+                    category: 'title',
                     status: 'warn',
-                    message: `Title is too short (${titleLength} chars)`,
+                    message: `Title is ${titleLength} characters`,
                     value: titleLength,
                     recommendation: 'Title should be 50-60 characters',
                 });
@@ -102,6 +169,7 @@ export class SeoSpider {
             else if (titleLength > 60) {
                 checks.push({
                     name: 'Title Length',
+                    category: 'title',
                     status: 'warn',
                     message: `Title is too long (${titleLength} chars)`,
                     value: titleLength,
@@ -111,6 +179,7 @@ export class SeoSpider {
             else {
                 checks.push({
                     name: 'Title Length',
+                    category: 'title',
                     status: 'pass',
                     message: `Good title length (${titleLength} chars)`,
                     value: titleLength,
@@ -120,6 +189,7 @@ export class SeoSpider {
         else {
             checks.push({
                 name: 'Title',
+                category: 'title',
                 status: 'fail',
                 message: 'Page has no title',
                 recommendation: 'Add a descriptive <title> tag',
@@ -130,6 +200,7 @@ export class SeoSpider {
         if (internalLinks === 0) {
             checks.push({
                 name: 'Internal Links',
+                category: 'links',
                 status: 'warn',
                 message: 'No internal links found',
                 recommendation: 'Add internal links to improve site structure',
@@ -138,6 +209,7 @@ export class SeoSpider {
         else {
             checks.push({
                 name: 'Internal Links',
+                category: 'links',
                 status: 'pass',
                 message: `${internalLinks} internal links found`,
                 value: internalLinks,
@@ -232,27 +304,19 @@ export class SeoSpider {
                 missingDimensions: 0,
                 modernFormats: 0,
                 altTextLengths: [],
+                imageAltTexts: [],
                 imageFilenames: [],
                 imagesWithAsyncDecoding: 0,
             },
             social: {
                 openGraph: {
-                    present: false,
-                    hasTitle: false,
-                    hasDescription: false,
-                    hasImage: false,
-                    hasUrl: false,
-                    issues: [],
+                    present: false, hasTitle: false, hasDescription: false, hasImage: false, hasUrl: false, issues: []
                 },
                 twitterCard: {
-                    present: false,
-                    hasCard: false,
-                    hasTitle: false,
-                    hasDescription: false,
-                    hasImage: false,
-                    issues: [],
+                    present: false, hasCard: false, hasTitle: false, hasDescription: false, hasImage: false, issues: []
                 },
             },
+            keywords: { totalWords: 0, uniqueWords: 0, topKeywords: [] },
             technical: {
                 hasCanonical: false,
                 hasRobotsMeta: false,

package/dist/seo/types.d.ts

@@ -1,3 +1,5 @@
+import { KeywordCloud } from './keywords.js';
+export type { KeywordCloud, KeywordItem } from './keywords.js';
 export type SeoStatus = 'pass' | 'warn' | 'fail' | 'info';
 export interface SeoCheckEvidence {
     found?: string | number | string[];
@@ -10,6 +12,7 @@ export interface SeoCheckEvidence {
 }
 export interface SeoCheckResult {
     name: string;
+    category: string;
     status: SeoStatus;
     message: string;
     value?: string | number;
@@ -50,6 +53,8 @@ export interface LinkAnalysis {
     withoutText: number;
     sponsoredLinks: number;
     ugcLinks: number;
+    internalHttpLinks?: number;
+    internalHttpLinkUrls?: string[];
 }
 export interface ImageAnalysis {
     total: number;
@@ -59,6 +64,7 @@ export interface ImageAnalysis {
     missingDimensions: number;
     modernFormats: number;
     altTextLengths: number[];
+    imageAltTexts: string[];
     imageFilenames: string[];
     imagesWithAsyncDecoding: number;
 }
@@ -172,8 +178,9 @@ export interface SeoReport {
         types: string[];
         items: Record<string, unknown>[];
     };
-    headings: HeadingAnalysis;
     content: ContentMetrics;
+    headings: HeadingAnalysis;
+    keywords: KeywordCloud;
     links: LinkAnalysis;
     images: ImageAnalysis;
     social: SocialMetaAnalysis;

package/dist/seo/validators/llms-txt.js

@@ -1,6 +1,8 @@
 const MAX_FILE_SIZE = 100 * 1024;
 const MIN_DESCRIPTION_LENGTH = 50;
 const MAX_DESCRIPTION_LENGTH = 500;
+const OPTIMAL_MIN_LINKS = 10;
+const OPTIMAL_MAX_LINKS = 30;
 export function parseLlmsTxt(content) {
     const errors = [];
     const warnings = [];
@@ -181,6 +183,23 @@ export function validateLlmsTxt(content, baseUrl) {
             seenUrls.add(normalized);
         }
     }
+    const linkCount = parseResult.links.length;
+    if (linkCount > 0 && linkCount < OPTIMAL_MIN_LINKS) {
+        issues.push({
+            type: 'info',
+            code: 'FEW_LINKS',
+            message: `Only ${linkCount} link(s) found in llms.txt`,
+            recommendation: `Consider adding ${OPTIMAL_MIN_LINKS}-${OPTIMAL_MAX_LINKS} of your most valuable pages for better AI coverage`,
+        });
+    }
+    else if (linkCount > OPTIMAL_MAX_LINKS) {
+        issues.push({
+            type: 'info',
+            code: 'MANY_LINKS',
+            message: `${linkCount} links found in llms.txt`,
+            recommendation: `Focus on quality over quantity. ${OPTIMAL_MIN_LINKS}-${OPTIMAL_MAX_LINKS} high-value links are recommended to help AI systems identify your truly important content`,
+        });
+    }
     return {
         valid: issues.filter(i => i.type === 'error').length === 0,
         issues,

package/dist/seo/validators/rss.d.ts

@@ -0,0 +1,11 @@
+export interface RssFeed {
+    url: string;
+    type: 'rss' | 'atom' | 'unknown';
+    title?: string;
+    description?: string;
+    itemCount: number;
+    lastBuildDate?: string;
+    isValid: boolean;
+    error?: string;
+}
+export declare function discoverFeeds(baseUrl: string, html?: string): Promise<RssFeed[]>;

package/dist/seo/validators/rss.js

@@ -0,0 +1,93 @@
+import { createClient } from '../../core/client.js';
+const COMMON_PATHS = [
+    '/rss.xml',
+    '/feed.xml',
+    '/rss',
+    '/feed',
+    '/atom.xml',
+    '/feeds/posts/default',
+    '/index.xml'
+];
+export async function discoverFeeds(baseUrl, html) {
+    const candidateUrls = new Set();
+    const feeds = [];
+    if (html) {
+        const linkRegex = /<link[^>]+?type=["']application\/(rss\+xml|atom\+xml)["'][^>]*?>/gi;
+        const hrefRegex = /href=["']([^"']+)["']/;
+        const titleRegex = /title=["']([^"']+)["']/;
+        let match;
+        while ((match = linkRegex.exec(html)) !== null) {
+            const tag = match[0];
+            const hrefMatch = hrefRegex.exec(tag);
+            if (hrefMatch) {
+                let href = hrefMatch[1];
+                try {
+                    href = new URL(href, baseUrl).toString();
+                    candidateUrls.add(href);
+                }
+                catch { }
+            }
+        }
+    }
+    if (candidateUrls.size === 0) {
+        for (const path of COMMON_PATHS) {
+            try {
+                const url = new URL(path, baseUrl).toString();
+                candidateUrls.add(url);
+            }
+            catch { }
+        }
+    }
+    const client = createClient({ timeout: 8000 });
+    await Promise.all(Array.from(candidateUrls).map(async (url) => {
+        try {
+            const response = await client.get(url);
+            if (response.status !== 200)
+                return;
+            const contentType = response.headers.get('content-type') || '';
+            const text = await response.text();
+            let type = 'unknown';
+            let isValid = false;
+            let itemCount = 0;
+            let title;
+            let description;
+            let lastBuildDate;
+            if (text.includes('<rss') && text.includes('version="2.0"')) {
+                type = 'rss';
+                isValid = true;
+                itemCount = (text.match(/<item>/g) || []).length;
+                const titleMatch = text.match(/<channel>[\s\S]*?<title>(.*?)<\/title>/);
+                if (titleMatch)
+                    title = titleMatch[1].replace(/<!\[CDATA\[(.*?)\]\]>/g, '$1').trim();
+                const descMatch = text.match(/<channel>[\s\S]*?<description>(.*?)<\/description>/);
+                if (descMatch)
+                    description = descMatch[1].replace(/<!\[CDATA\[(.*?)\]\]>/g, '$1').trim();
+                const dateMatch = text.match(/<lastBuildDate>(.*?)<\/lastBuildDate>/);
+                if (dateMatch)
+                    lastBuildDate = dateMatch[1];
+            }
+            else if (text.includes('<feed') && text.includes('xmlns="http://www.w3.org/2005/Atom"')) {
+                type = 'atom';
+                isValid = true;
+                itemCount = (text.match(/<entry>/g) || []).length;
+                const titleMatch = text.match(/<title>(.*?)<\/title>/);
+                if (titleMatch)
+                    title = titleMatch[1].trim();
+            }
+            if (isValid) {
+                feeds.push({
+                    url,
+                    type,
+                    isValid,
+                    title,
+                    description,
+                    itemCount,
+                    lastBuildDate
+                });
+            }
+        }
+        catch (err) {
+        }
+    }));
+    return feeds;
+}

package/dist/seo/validators/sitemap.js

@@ -1,4 +1,4 @@
-import * as cheerio from 'cheerio';
+import { parse } from '../../scrape/parser/index.js';
 const VALID_CHANGEFREQ = ['always', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', 'never'];
 const MAX_URLS_PER_SITEMAP = 50000;
 const MAX_SITEMAP_SIZE = 50 * 1024 * 1024;
@@ -9,12 +9,12 @@ export function parseSitemap(content, compressed = false) {
     const sitemaps = [];
     let type = 'unknown';
     try {
-        const $ = cheerio.load(content, { xmlMode: true });
-        if ($('urlset').length > 0) {
+        const root = parse(content, { lowerCaseTagName: false });
+        if (root.querySelectorAll('urlset').length > 0) {
             type = 'urlset';
-            $('url').each((_, elem) => {
-                const $url = $(elem);
-                const loc = $url.find('loc').first().text().trim();
+            root.querySelectorAll('url').forEach((urlElem) => {
+                const locElem = urlElem.querySelector('loc');
+                const loc = locElem ? locElem.text.trim() : '';
                 if (!loc) {
                     errors.push('URL entry missing <loc> element');
                     return;
@@ -27,7 +27,8 @@ export function parseSitemap(content, compressed = false) {
                     return;
                 }
                 const url = { loc };
-                const lastmod = $url.find('lastmod').first().text().trim();
+                const lastmodElem = urlElem.querySelector('lastmod');
+                const lastmod = lastmodElem ? lastmodElem.text.trim() : '';
                 if (lastmod) {
                     if (isValidDate(lastmod)) {
                         url.lastmod = lastmod;
@@ -36,7 +37,8 @@ export function parseSitemap(content, compressed = false) {
                         warnings.push(`Invalid lastmod date for ${loc}: ${lastmod}`);
                     }
                 }
-                const changefreq = $url.find('changefreq').first().text().trim().toLowerCase();
+                const changefreqElem = urlElem.querySelector('changefreq');
+                const changefreq = changefreqElem ? changefreqElem.text.trim().toLowerCase() : '';
                 if (changefreq) {
                     if (VALID_CHANGEFREQ.includes(changefreq)) {
                         url.changefreq = changefreq;
@@ -45,7 +47,8 @@ export function parseSitemap(content, compressed = false) {
                         warnings.push(`Invalid changefreq for ${loc}: ${changefreq}`);
                     }
                 }
-                const priority = $url.find('priority').first().text().trim();
+                const priorityElem = urlElem.querySelector('priority');
+                const priority = priorityElem ? priorityElem.text.trim() : '';
                 if (priority) {
                     const p = parseFloat(priority);
                     if (isNaN(p) || p < 0 || p > 1) {
@@ -56,14 +59,17 @@ export function parseSitemap(content, compressed = false) {
                     }
                 }
                 const images = [];
-                $url.find('image\\:image, image').each((_, imgElem) => {
-                    const $img = $(imgElem);
-                    const imgLoc = $img.find('image\\:loc, loc').first().text().trim();
+                const imageElems = urlElem.querySelectorAll('image\:image, image');
+                imageElems.forEach((imgElem) => {
+                    const locEl = imgElem.querySelector('image\:loc, loc');
+                    const imgLoc = locEl ? locEl.text.trim() : '';
                     if (imgLoc) {
+                        const captionEl = imgElem.querySelector('image\:caption, caption');
+                        const titleEl = imgElem.querySelector('image\:title, title');
                         images.push({
                             loc: imgLoc,
-                            caption: $img.find('image\\:caption, caption').first().text().trim() || undefined,
-                            title: $img.find('image\\:title, title').first().text().trim() || undefined,
+                            caption: captionEl ? captionEl.text.trim() || undefined : undefined,
+                            title: titleEl ? titleEl.text.trim() || undefined : undefined,
                         });
                     }
                 });
@@ -71,10 +77,10 @@ export function parseSitemap(content, compressed = false) {
                     url.images = images;
                 }
                 const alternates = [];
-                $url.find('xhtml\\:link[rel="alternate"], link[rel="alternate"]').each((_, linkElem) => {
-                    const $link = $(linkElem);
-                    const hreflang = $link.attr('hreflang');
-                    const href = $link.attr('href');
+                const linkElems = urlElem.querySelectorAll('xhtml\:link[rel="alternate"], link[rel="alternate"]');
+                linkElems.forEach((linkElem) => {
+                    const hreflang = linkElem.getAttribute('hreflang');
+                    const href = linkElem.getAttribute('href');
                     if (hreflang && href) {
                         alternates.push({ hreflang, href });
                     }
@@ -85,17 +91,18 @@ export function parseSitemap(content, compressed = false) {
                 urls.push(url);
             });
         }
-        else if ($('sitemapindex').length > 0) {
+        else if (root.querySelectorAll('sitemapindex').length > 0) {
             type = 'sitemapindex';
-            $('sitemap').each((_, elem) => {
-                const $sitemap = $(elem);
-                const loc = $sitemap.find('loc').first().text().trim();
+            root.querySelectorAll('sitemap').forEach((sitemapElem) => {
+                const locElem = sitemapElem.querySelector('loc');
+                const loc = locElem ? locElem.text.trim() : '';
                 if (!loc) {
                     errors.push('Sitemap entry missing <loc> element');
                     return;
                 }
                 const sitemap = { loc };
-                const lastmod = $sitemap.find('lastmod').first().text().trim();
+                const lastmodElem = sitemapElem.querySelector('lastmod');
+                const lastmod = lastmodElem ? lastmodElem.text.trim() : '';
                 if (lastmod) {
                     if (isValidDate(lastmod)) {
                         sitemap.lastmod = lastmod;
@@ -285,6 +292,9 @@ export async function discoverSitemaps(baseUrl, robotsTxtContent, fetcher) {
             }
         }
     }
+    if (discovered.size > 0) {
+        return Array.from(discovered);
+    }
     for (const path of commonLocations) {
         const url = new URL(path, base).href;
         try {
@@ -399,9 +409,9 @@ export async function fetchAndValidateSitemap(url, fetcher) {
 }
 function isValidDate(dateString) {
     const patterns = [
-        /^\d{4}-\d{2}-\d{2}$/,
-        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}([+-]\d{2}:\d{2}|Z)$/,
-        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}([+-]\d{2}:\d{2}|Z)$/,
+        /\d{4}-\d{2}-\d{2}$/,
+        /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}([+-]\d{2}:\d{2}|Z)$/,
+        /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}([+-]\d{2}:\d{2}|Z)$/,
     ];
     if (!patterns.some(p => p.test(dateString))) {
         return false;

package/dist/transport/curl.d.ts

@@ -0,0 +1,4 @@
+import { Transport, ReckerRequest, ReckerResponse } from '../types/index.js';
+export declare class CurlTransport implements Transport {
+    dispatch(req: ReckerRequest): Promise<ReckerResponse>;
+}