sneakoscope 4.4.0 → 4.6.0

package/dist/core/search-visibility/artifacts.js

@@ -0,0 +1,183 @@
+import path from 'node:path';
+import { maybeFinalizeRoute } from '../proof/auto-finalize.js';
+import { PACKAGE_VERSION, exists, readJson, writeJsonAtomic } from '../fsx.js';
+import { buildAiCrawlerPolicy, buildCanonicalMap, buildInternalLinkGraph, buildLlmsTxtPlan, buildLocaleGraph, buildRobotsPolicy, buildRouteGraph, buildSitemapAudit, buildStructuredDataLedger, } from './analyzers.js';
+import { findingsFileForMode, gateFileForMode, missionRel, routeForMode } from './mission.js';
+import { verifySearchVisibility } from './verifier.js';
+const COMMON_ARTIFACTS = [
+    'intake.json',
+    'adapter-detection.json',
+    'site-inventory.json',
+    'route-graph.json',
+    'robots-policy.json',
+    'structured-data-ledger.json',
+    'verification-report.json',
+];
+export async function writeAuditArtifacts(ctx, mission, inventory, findings, geo) {
+    const route = routeForMode(ctx.mode);
+    await writeJsonAtomic(path.join(mission.artifactDir, 'adapter-detection.json'), withMeta(ctx, mission, {
+        schema: 'sks.search-visibility.adapter-detection.v1',
+        ...inventory.detected_adapter,
+    }));
+    await writeJsonAtomic(path.join(mission.artifactDir, 'site-inventory.json'), withMeta(ctx, mission, inventory));
+    await writeJsonAtomic(path.join(mission.artifactDir, 'route-graph.json'), withMeta(ctx, mission, buildRouteGraph(inventory)));
+    await writeJsonAtomic(path.join(mission.artifactDir, findingsFileForMode(ctx.mode)), withMeta(ctx, mission, {
+        schema: `sks.search-visibility.${ctx.mode}-findings.v1`,
+        findings,
+        counts: countFindings(findings),
+    }));
+    await writeJsonAtomic(path.join(mission.artifactDir, 'canonical-map.json'), withMeta(ctx, mission, buildCanonicalMap(inventory)));
+    await writeJsonAtomic(path.join(mission.artifactDir, 'locale-graph.json'), withMeta(ctx, mission, buildLocaleGraph(inventory)));
+    await writeJsonAtomic(path.join(mission.artifactDir, 'sitemap-audit.json'), withMeta(ctx, mission, buildSitemapAudit(inventory)));
+    await writeJsonAtomic(path.join(mission.artifactDir, 'robots-policy.json'), withMeta(ctx, mission, buildRobotsPolicy(inventory, geo?.crawlers)));
+    await writeJsonAtomic(path.join(mission.artifactDir, 'structured-data-ledger.json'), withMeta(ctx, mission, buildStructuredDataLedger(inventory)));
+    await writeJsonAtomic(path.join(mission.artifactDir, 'internal-link-graph.json'), withMeta(ctx, mission, buildInternalLinkGraph(inventory)));
+    if (geo) {
+        await writeJsonAtomic(path.join(mission.artifactDir, 'entity-facts.json'), withMeta(ctx, mission, geo.entityFacts));
+        await writeJsonAtomic(path.join(mission.artifactDir, 'claim-evidence-ledger.json'), withMeta(ctx, mission, {
+            schema: 'sks.search-visibility.claim-evidence-ledger.v1',
+            claims: geo.claims,
+        }));
+        await writeJsonAtomic(path.join(mission.artifactDir, 'answerability-report.json'), withMeta(ctx, mission, geo.answerability));
+        await writeJsonAtomic(path.join(mission.artifactDir, 'ai-crawler-policy.json'), withMeta(ctx, mission, buildAiCrawlerPolicy()));
+        await writeJsonAtomic(path.join(mission.artifactDir, 'llms-txt-plan.json'), withMeta(ctx, mission, buildLlmsTxtPlan(inventory, geo.entityFacts)));
+    }
+    const verification = await verifySearchVisibility(ctx, inventory, mission);
+    await writeJsonAtomic(path.join(mission.artifactDir, 'verification-report.json'), withMeta(ctx, mission, verification));
+    const gate = await writeGate(ctx, mission, findings, verification, Boolean(geo));
+    const proof = await finalizeSearchVisibility(ctx, mission, gate);
+    return { verification, gate, proof };
+}
+export async function writeGate(ctx, mission, findings, verification, includeGeoArtifacts) {
+    const route = routeForMode(ctx.mode);
+    const gateFile = gateFileForMode(ctx.mode);
+    const required = requiredArtifacts(ctx.mode, includeGeoArtifacts);
+    const requiredStatus = await Promise.all(required.map(async (artifact) => {
+        if (artifact === gateFile)
+            return { path: gateFile, present: true };
+        if (artifact === 'completion-proof.json')
+            return { path: artifact, present: true };
+        const file = artifact === gateFile || artifact === 'completion-proof.json'
+            ? path.join(mission.dir, artifact)
+            : path.join(mission.artifactDir, artifact);
+        return { path: artifact === 'completion-proof.json' ? artifact : artifact === gateFile ? gateFile : `search-visibility/${artifact}`, present: await exists(file) };
+    }));
+    const unsupportedClaims = findings
+        .filter((finding) => finding.severity === 'critical' && /guarantee|ranking|traffic|citation|unsupported/i.test(finding.summary))
+        .map((finding) => finding.id);
+    const artifactBlockers = requiredStatus.filter((item) => !item.present && item.path !== 'completion-proof.json').map((item) => `missing:${item.path}`);
+    const findingBlockers = findings.filter((finding) => finding.blocking && !/unsupported ranking|Unsupported ranking/i.test(finding.summary)).map((finding) => finding.id);
+    const blockers = [...artifactBlockers, ...verification.blockers, ...findingBlockers];
+    const unverified = Array.from(new Set([
+        ...verification.unverified,
+        'production URL, browser rendering, Search Console, analytics, ranking, traffic, and AI citation outcomes are not claimed without direct evidence',
+    ]));
+    const ok = blockers.length === 0 && unsupportedClaims.length === 0;
+    const gate = {
+        schema: 'sks.search-visibility.gate.v1',
+        generated_at: new Date().toISOString(),
+        mission_id: mission.id,
+        route,
+        ok,
+        passed: ok,
+        status: ok ? 'verified_partial' : 'blocked',
+        command_identity: route === '$SEO-GEO-OPTIMIZER',
+        required_artifacts: requiredStatus,
+        unsupported_claims: unsupportedClaims,
+        blockers,
+        unverified,
+        completion_proof: `.sneakoscope/missions/${mission.id}/completion-proof.json`,
+    };
+    await writeJsonAtomic(path.join(mission.dir, gateFile), gate);
+    return gate;
+}
+export async function finalizeSearchVisibility(ctx, mission, gate, command = `sks ${ctx.mode} audit --json`) {
+    const route = routeForMode(ctx.mode);
+    const artifacts = [
+        ...requiredArtifacts(ctx.mode, ctx.mode === 'geo').map((artifact) => artifact === gateFileForMode(ctx.mode) ? artifact : `search-visibility/${artifact}`),
+        gateFileForMode(ctx.mode),
+        'completion-proof.json',
+    ];
+    return maybeFinalizeRoute(mission.root, {
+        missionId: mission.id,
+        route,
+        gateFile: gateFileForMode(ctx.mode),
+        gate,
+        artifacts,
+        statusHint: gate.ok ? 'verified_partial' : 'blocked',
+        blockers: gate.blockers,
+        unverified: gate.unverified,
+        command: { cmd: command, status: gate.ok ? 0 : 1 },
+        agents: false,
+        lightweightEvidence: true,
+    });
+}
+export function requiredArtifacts(mode, includeGeoArtifacts = mode === 'geo') {
+    const seo = [
+        ...COMMON_ARTIFACTS,
+        'seo-findings.json',
+        'canonical-map.json',
+        'locale-graph.json',
+        'sitemap-audit.json',
+        'internal-link-graph.json',
+        'seo-gate.json',
+        'completion-proof.json',
+    ];
+    if (mode === 'seo')
+        return seo;
+    return [
+        ...COMMON_ARTIFACTS,
+        'geo-findings.json',
+        'canonical-map.json',
+        'locale-graph.json',
+        'sitemap-audit.json',
+        'internal-link-graph.json',
+        ...(includeGeoArtifacts ? ['entity-facts.json', 'claim-evidence-ledger.json', 'answerability-report.json', 'ai-crawler-policy.json', 'llms-txt-plan.json'] : []),
+        'geo-gate.json',
+        'completion-proof.json',
+    ];
+}
+export async function statusForMission(mission) {
+    const seoGate = await readJson(path.join(mission.dir, 'seo-gate.json'), null);
+    const geoGate = await readJson(path.join(mission.dir, 'geo-gate.json'), null);
+    const verification = await readJson(path.join(mission.artifactDir, 'verification-report.json'), null);
+    const plan = await readJson(path.join(mission.artifactDir, 'mutation-plan.json'), null);
+    const proof = await readJson(path.join(mission.dir, 'completion-proof.json'), null);
+    return {
+        schema: 'sks.search-visibility.status.v1',
+        ok: Boolean(seoGate?.ok || geoGate?.ok || verification),
+        mission_id: mission.id,
+        artifacts_dir: missionRel(mission.id, ''),
+        gate: seoGate || geoGate,
+        verification,
+        mutation_plan: plan,
+        completion_proof: proof ? `.sneakoscope/missions/${mission.id}/completion-proof.json` : null,
+    };
+}
+function withMeta(ctx, mission, data) {
+    const value = data && typeof data === 'object' && !Array.isArray(data) ? data : { value: data };
+    return {
+        ...value,
+        generated_at: value.generated_at || new Date().toISOString(),
+        package_version: PACKAGE_VERSION,
+        mission_id: mission.id,
+        route: routeForMode(ctx.mode),
+        root: mission.root,
+        target: ctx.target,
+        source_commit: null,
+        input_hashes: {},
+        tool_versions: { sneakoscope: PACKAGE_VERSION },
+        network_used: Boolean(ctx.origin && !ctx.offline),
+        browser_used: false,
+        status: value.status || 'verified_partial',
+        blockers: Array.isArray(value.blockers) ? value.blockers : [],
+        unverified: Array.isArray(value.unverified) ? value.unverified : [],
+    };
+}
+function countFindings(findings) {
+    const counts = {};
+    for (const finding of findings)
+        counts[finding.severity] = (counts[finding.severity] || 0) + 1;
+    return counts;
+}
+//# sourceMappingURL=artifacts.js.map

package/dist/core/search-visibility/discovery.js

@@ -0,0 +1,347 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { exists, readJson, readText, sha256 } from '../fsx.js';
+const MAX_DISCOVERY_FILES = 2500;
+const DEFAULT_CAPABILITIES = {
+    sourceAudit: true,
+    builtHtmlAudit: false,
+    liveHttpAudit: false,
+    renderedBrowserAudit: false,
+    metadataMutation: false,
+    sitemapMutation: false,
+    robotsMutation: false,
+    structuredDataMutation: false,
+    localeMutation: false,
+};
+export async function detectProject(ctx) {
+    const files = await walkFiles(ctx.root, MAX_DISCOVERY_FILES);
+    const rels = new Set(files);
+    const packageJson = await readJson(path.join(ctx.root, 'package.json'), {});
+    const deps = {
+        ...(isRecord(packageJson.dependencies) ? packageJson.dependencies : {}),
+        ...(isRecord(packageJson.devDependencies) ? packageJson.devDependencies : {}),
+    };
+    const hasNext = Object.hasOwn(deps, 'next') || rels.has('next.config.js') || rels.has('next.config.mjs') || rels.has('next.config.ts');
+    const appEvidence = files.find((file) => /(?:^|\/)app\/(?:layout|page)\.(?:tsx|ts|jsx|js|mdx)$/.test(file));
+    const pagesEvidence = files.find((file) => /(?:^|\/)pages\/(?:index|_app|_document|.+)\.(?:tsx|ts|jsx|js|mdx)$/.test(file));
+    const staticEvidence = files.find((file) => /(?:^|\/)(?:public\/)?index\.html$/.test(file));
+    const forced = ctx.framework !== 'auto' ? ctx.framework : null;
+    if (forced && forced !== 'unsupported')
+        return forcedDetection(forced, files);
+    if (hasNext && appEvidence)
+        return detection('next-app', 0.95, [{ path: appEvidence, reason: 'Next.js App Router route source found' }], mutationCapabilities('next-app'));
+    if (hasNext && pagesEvidence)
+        return detection('next-pages', 0.9, [{ path: pagesEvidence, reason: 'Next.js Pages Router source found' }], mutationCapabilities('next-pages'));
+    if (staticEvidence)
+        return detection('static-site', 0.82, [{ path: staticEvidence, reason: 'Static HTML entry point found' }], mutationCapabilities('static'));
+    if (await exists(path.join(ctx.root, 'package.json')))
+        return detection('package', 0.75, [{ path: 'package.json', reason: 'Package metadata found' }], mutationCapabilities('package'));
+    return detection('unsupported', 0.25, [], DEFAULT_CAPABILITIES, ['No package, Next.js, or static HTML evidence found']);
+}
+export async function discoverSiteInventory(ctx, detected) {
+    const files = await walkFiles(ctx.root, MAX_DISCOVERY_FILES);
+    const packageJson = await readJson(path.join(ctx.root, 'package.json'), {});
+    const readmePath = await firstExisting(ctx.root, ['README.md', 'readme.md']);
+    const readme = readmePath ? await readText(path.join(ctx.root, readmePath), '') : '';
+    const htmlFiles = await Promise.all(files.filter((file) => file.endsWith('.html')).slice(0, 200).map((file) => summarizeHtml(ctx.root, file)));
+    const routes = discoverRoutes(files, htmlFiles);
+    const target = resolveTarget(ctx.target, detected, files);
+    const inventory = {
+        schema: 'sks.search-visibility.site-inventory.v1',
+        root: ctx.root,
+        origin: ctx.origin,
+        target,
+        detected_adapter: detected,
+        package: {
+            path: await exists(path.join(ctx.root, 'package.json')) ? 'package.json' : null,
+            name: stringOrNull(packageJson.name),
+            version: stringOrNull(packageJson.version),
+            description: stringOrNull(packageJson.description),
+            keywords: Array.isArray(packageJson.keywords) ? packageJson.keywords.map(String) : [],
+            repository: repositoryUrl(packageJson.repository),
+            homepage: stringOrNull(packageJson.homepage),
+            bugs: repositoryUrl(packageJson.bugs),
+            bin: isRecord(packageJson.bin) ? Object.keys(packageJson.bin) : (typeof packageJson.bin === 'string' ? [String(packageJson.name || '')].filter(Boolean) : []),
+            scripts: isRecord(packageJson.scripts) ? stringifyRecord(packageJson.scripts) : {},
+            framework_versions: frameworkVersions(packageJson),
+        },
+        readme: {
+            path: readmePath,
+            h1: firstMarkdownHeading(readme, 1),
+            headings: markdownHeadings(readme),
+            command_mentions: commandMentions(readme),
+            links: markdownLinks(readme),
+        },
+        routes,
+        html_files: htmlFiles,
+        policy_files: await policyFiles(ctx.root),
+        locale_candidates: discoverLocales(files, htmlFiles),
+        metadata_helpers: files.filter((file) => /(seo|metadata|schema|json-ld|structured-data|canonical|sitemap|robots)/i.test(file)).slice(0, 100),
+        structured_data_sources: files.filter((file) => /(schema|json-ld|structured-data|ld-json)/i.test(file)).slice(0, 100),
+        live_url_checked: Boolean(ctx.origin && !ctx.offline),
+        browser_checked: false,
+        generated_at: new Date().toISOString(),
+    };
+    return inventory;
+}
+export function sourceEvidence(pathValue, summary, hash = null, line = null) {
+    return {
+        type: 'source',
+        path: pathValue,
+        line,
+        selector: null,
+        hash,
+        url: null,
+        observed_at: new Date().toISOString(),
+        summary,
+    };
+}
+export function officialEvidence(url, summary) {
+    return {
+        type: 'official_source',
+        path: null,
+        line: null,
+        selector: null,
+        hash: null,
+        url,
+        observed_at: new Date().toISOString(),
+        summary,
+    };
+}
+export async function walkFiles(root, maxFiles = MAX_DISCOVERY_FILES) {
+    const out = [];
+    const ignored = new Set(['.git', 'node_modules', 'dist', '.next', '.sneakoscope', '.codex', '.agents', 'coverage', 'archive']);
+    async function walk(dir) {
+        if (out.length >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (out.length >= maxFiles)
+                return;
+            if (ignored.has(entry.name))
+                continue;
+            const full = path.join(dir, entry.name);
+            const rel = path.relative(root, full).split(path.sep).join('/');
+            if (entry.isDirectory())
+                await walk(full);
+            else if (entry.isFile())
+                out.push(rel);
+        }
+    }
+    await walk(root);
+    return out.sort();
+}
+function forcedDetection(framework, files) {
+    const adapterId = framework === 'static' ? 'static-site' : framework;
+    return detection(adapterId, 0.8, [{ path: files[0] || '.', reason: `Framework forced by --framework ${framework}` }], mutationCapabilities(framework));
+}
+function detection(adapterId, confidence, evidence, capabilities, blockers = []) {
+    return { adapterId, confidence, evidence, capabilities, blockers };
+}
+function mutationCapabilities(framework) {
+    const base = { ...DEFAULT_CAPABILITIES };
+    if (framework === 'next-app' || framework === 'next-pages') {
+        return { ...base, metadataMutation: true, sitemapMutation: true, robotsMutation: true, structuredDataMutation: true, localeMutation: true };
+    }
+    if (framework === 'static' || framework === 'static-site') {
+        return { ...base, builtHtmlAudit: true, metadataMutation: true, sitemapMutation: true, robotsMutation: true, structuredDataMutation: true };
+    }
+    if (framework === 'package')
+        return { ...base };
+    return base;
+}
+function resolveTarget(target, detected, files) {
+    if (target !== 'auto')
+        return target;
+    if (detected.adapterId === 'package')
+        return 'package';
+    if (files.some((file) => /(?:^|\/)(docs|documentation)\//i.test(file)))
+        return 'docs';
+    return detected.adapterId === 'unsupported' ? 'package' : 'website';
+}
+async function summarizeHtml(root, rel) {
+    const text = await readText(path.join(root, rel), '');
+    const jsonLdBlocks = Array.from(text.matchAll(/<script[^>]+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi));
+    const jsonLdParseErrors = [];
+    for (const match of jsonLdBlocks) {
+        const raw = match[1] || '';
+        try {
+            JSON.parse(raw.trim());
+        }
+        catch (err) {
+            jsonLdParseErrors.push(err instanceof Error ? err.message : String(err));
+        }
+    }
+    return {
+        path: rel,
+        title: tagText(text, 'title'),
+        description: metaContent(text, 'description'),
+        canonical: linkHref(text, 'canonical'),
+        robots: metaContent(text, 'robots'),
+        lang: htmlLang(text),
+        links: hrefs(text).slice(0, 500),
+        jsonLdCount: jsonLdBlocks.length,
+        jsonLdParseErrors,
+        visibleTextSample: stripTags(text).replace(/\s+/g, ' ').trim().slice(0, 500),
+    };
+}
+function discoverRoutes(files, htmlFiles) {
+    const routes = [];
+    for (const html of htmlFiles)
+        routes.push({ path: routePathFromHtml(html.path), source: html.path, kind: 'static', locale: localeFromPath(html.path) });
+    for (const file of files) {
+        const app = file.match(/(?:^|\/)app\/(.+)\/page\.(?:tsx|ts|jsx|js|mdx)$/);
+        if (app?.[1])
+            routes.push({ path: `/${normalizeRouteSegments(app[1])}`, source: file, kind: routeKind(app[1]), locale: localeFromPath(app[1]) });
+        const appRoot = file.match(/(?:^|\/)app\/page\.(?:tsx|ts|jsx|js|mdx)$/);
+        if (appRoot)
+            routes.push({ path: '/', source: file, kind: 'static', locale: null });
+        const pages = file.match(/(?:^|\/)pages\/(.+)\.(?:tsx|ts|jsx|js|mdx)$/);
+        if (pages?.[1] && !pages[1].startsWith('_'))
+            routes.push({ path: `/${normalizeRouteSegments(pages[1].replace(/\/index$/, ''))}`, source: file, kind: routeKind(pages[1]), locale: localeFromPath(pages[1]) });
+    }
+    const byKey = new Map();
+    for (const route of routes)
+        byKey.set(`${route.path}:${route.source}`, route);
+    return Array.from(byKey.values()).sort((a, b) => a.path.localeCompare(b.path));
+}
+async function policyFiles(root) {
+    const specs = [
+        ['robots.txt', 'robots'],
+        ['public/robots.txt', 'robots'],
+        ['sitemap.xml', 'sitemap'],
+        ['public/sitemap.xml', 'sitemap'],
+        ['llms.txt', 'llms'],
+        ['public/llms.txt', 'llms'],
+        ['site.webmanifest', 'manifest'],
+        ['public/site.webmanifest', 'manifest'],
+    ];
+    const out = [];
+    for (const [rel, kind] of specs) {
+        const full = path.join(root, rel);
+        const present = await exists(full);
+        const text = present ? await readText(full, '') : '';
+        out.push({
+            path: rel,
+            kind,
+            exists: present,
+            managed: /sks-search-visibility|BEGIN SKS SEARCH VISIBILITY/i.test(text),
+            hash: present ? sha256(text) : null,
+        });
+    }
+    return out;
+}
+function discoverLocales(files, htmlFiles) {
+    const candidates = new Map();
+    for (const html of htmlFiles) {
+        if (html.lang)
+            candidates.set(html.lang, { code: html.lang, source: `${html.path}#html-lang`, confidence: 0.9 });
+    }
+    for (const file of files) {
+        const locale = localeFromPath(file);
+        if (locale && !candidates.has(locale))
+            candidates.set(locale, { code: locale, source: file, confidence: 0.7 });
+    }
+    return Array.from(candidates.values()).sort((a, b) => a.code.localeCompare(b.code));
+}
+function routePathFromHtml(rel) {
+    const normalized = rel.replace(/^public\//, '').replace(/index\.html$/, '').replace(/\.html$/, '');
+    const route = `/${normalized}`.replace(/\/+/g, '/');
+    return route === '/' ? '/' : route.replace(/\/$/, '');
+}
+function normalizeRouteSegments(value) {
+    return value
+        .replace(/\/index$/, '')
+        .replace(/\[(\.\.\.)?([^\]]+)\]/g, ':$2')
+        .replace(/^\(([^)]+)\)\//, '')
+        .replace(/\/+/g, '/')
+        .replace(/^\/|\/$/g, '');
+}
+function routeKind(value) {
+    if (/\[.+\]|:\w+/.test(value))
+        return 'parameterized';
+    return 'static';
+}
+function localeFromPath(value) {
+    const first = value.split('/').find(Boolean) || '';
+    return /^[a-z]{2}(?:-[A-Z]{2})?$/.test(first) ? first : null;
+}
+async function firstExisting(root, rels) {
+    for (const rel of rels) {
+        if (await exists(path.join(root, rel)))
+            return rel;
+    }
+    return null;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function stringifyRecord(value) {
+    return Object.fromEntries(Object.entries(value).map(([key, val]) => [key, String(val)]));
+}
+function stringOrNull(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function repositoryUrl(value) {
+    if (typeof value === 'string')
+        return value;
+    if (isRecord(value) && typeof value.url === 'string')
+        return value.url;
+    return null;
+}
+function frameworkVersions(packageJson) {
+    const deps = {
+        ...(isRecord(packageJson.dependencies) ? packageJson.dependencies : {}),
+        ...(isRecord(packageJson.devDependencies) ? packageJson.devDependencies : {}),
+    };
+    const names = ['next', 'react', 'astro', 'nuxt', 'svelte', 'vite'];
+    return Object.fromEntries(names.filter((name) => typeof deps[name] === 'string').map((name) => [name, String(deps[name])]));
+}
+function firstMarkdownHeading(text, level) {
+    const prefix = '#'.repeat(level);
+    const line = text.split(/\r?\n/).find((row) => row.startsWith(`${prefix} `));
+    return line ? line.replace(/^#+\s*/, '').trim() : null;
+}
+function markdownHeadings(text) {
+    return text.split(/\r?\n/).filter((line) => /^#{1,6}\s+/.test(line)).map((line) => line.replace(/^#+\s*/, '').trim()).slice(0, 200);
+}
+function commandMentions(text) {
+    return Array.from(new Set(Array.from(text.matchAll(/\b(?:sks|npx|npm|node)\s+[^\n`]{1,80}/g)).map((m) => (m[0] || '').trim()).filter(Boolean))).slice(0, 100);
+}
+function markdownLinks(text) {
+    return Array.from(new Set(Array.from(text.matchAll(/\[[^\]]+\]\(([^)]+)\)/g)).map((m) => m[1] || '').filter(Boolean))).slice(0, 500);
+}
+function tagText(text, tag) {
+    const re = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'i');
+    const match = text.match(re);
+    return match?.[1] ? stripTags(match[1]).trim() || null : null;
+}
+function metaContent(text, name) {
+    const re = new RegExp(`<meta[^>]+(?:name|property)=["']${escapeRegex(name)}["'][^>]*content=["']([^"']+)["'][^>]*>`, 'i');
+    const alt = new RegExp(`<meta[^>]+content=["']([^"']+)["'][^>]*(?:name|property)=["']${escapeRegex(name)}["'][^>]*>`, 'i');
+    return text.match(re)?.[1] || text.match(alt)?.[1] || null;
+}
+function linkHref(text, rel) {
+    const re = new RegExp(`<link[^>]+rel=["']${escapeRegex(rel)}["'][^>]*href=["']([^"']+)["'][^>]*>`, 'i');
+    const alt = new RegExp(`<link[^>]+href=["']([^"']+)["'][^>]*rel=["']${escapeRegex(rel)}["'][^>]*>`, 'i');
+    return text.match(re)?.[1] || text.match(alt)?.[1] || null;
+}
+function htmlLang(text) {
+    return text.match(/<html[^>]+lang=["']([^"']+)["']/i)?.[1] || null;
+}
+function hrefs(text) {
+    return Array.from(new Set(Array.from(text.matchAll(/<a[^>]+href=["']([^"']+)["']/gi)).map((m) => m[1] || '').filter(Boolean)));
+}
+function stripTags(text) {
+    return text.replace(/<script[\s\S]*?<\/script>/gi, ' ').replace(/<style[\s\S]*?<\/style>/gi, ' ').replace(/<[^>]+>/g, ' ');
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+//# sourceMappingURL=discovery.js.map