@taurgis/bonsai 1.0.6 → 3.0.0

package/dist/lib/research/{search-index.d.ts → artifact-index.d.ts}

@@ -1,18 +1,18 @@
 import type { ResearchArtifact } from './schema.js';
-export interface SearchableArtifact {
+export interface IndexedArtifact {
     artifact: ResearchArtifact;
     filePath: string;
 }
 /**
- * Returns the searchable view of every active artifact in one research dir, using the sidecar index
+ * Returns the indexed view of every active artifact in one research dir, using the sidecar index
  * to skip unchanged files. Re-reads only files whose signature changed, then persists the refreshed
- * index (best-effort; a write failure never breaks search). Corrupt/unreadable files are skipped —
+ * index (best-effort; a write failure never breaks callers). Corrupt/unreadable files are skipped —
  * the real read paths in storage.ts handle archiving them.
  */
-export declare function loadSearchableArtifactsForDir(researchDir: string): SearchableArtifact[];
+export declare function loadIndexedArtifactsForDir(researchDir: string): IndexedArtifact[];
 /**
  * Multi-root variant: scans the `research/` dir of each data dir in order and deduplicates by cache
  * key so a project entry shadows the same key in the global cache. Mirrors the dedup semantics of
  * {@link scanCacheDirs} but reads through the per-root sidecar index.
  */
-export declare function loadSearchableArtifacts(dataDirs: string[]): SearchableArtifact[];
+export declare function loadIndexedArtifacts(dataDirs: string[]): IndexedArtifact[];

package/dist/lib/research/{search-index.js → artifact-index.js}

@@ -2,11 +2,11 @@ import { join } from 'node:path';
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { atomicWriteFile } from '../atomic-write.js';
 import { parseArtifactShallow } from './artifact.js';
-import { isResearchFile } from './storage.js';
+import { isResearchFile } from './url.js';
 // Sidecar index that caches the lightweight (metadata + summary + compressed) view of each artifact
-// so repeat searches avoid re-reading and re-parsing every file. It is a derived cache only: a stale
-// or missing index never changes results, because each entry is validated against the file's current
-// signature and re-read on any mismatch.
+// so repeat list/scan operations avoid re-reading and re-parsing every file. It is a derived cache
+// only: a stale or missing index never changes results, because each entry is validated against the
+// file's current signature and re-read on any mismatch.
 const INDEX_FILE = '.search-index.json';
 const INDEX_VERSION = 1;
 // The repo writes artifacts via temp-file + rename, so every rewrite yields a new inode. Combining
@@ -48,12 +48,12 @@ function getOrUpdateIndexEntry(filePath, cached, onChanged) {
     }
 }
 /**
- * Returns the searchable view of every active artifact in one research dir, using the sidecar index
+ * Returns the indexed view of every active artifact in one research dir, using the sidecar index
  * to skip unchanged files. Re-reads only files whose signature changed, then persists the refreshed
- * index (best-effort; a write failure never breaks search). Corrupt/unreadable files are skipped —
+ * index (best-effort; a write failure never breaks callers). Corrupt/unreadable files are skipped —
  * the real read paths in storage.ts handle archiving them.
  */
-export function loadSearchableArtifactsForDir(researchDir) {
+export function loadIndexedArtifactsForDir(researchDir) {
     if (!existsSync(researchDir))
         return [];
     const indexPath = join(researchDir, INDEX_FILE);
@@ -83,7 +83,7 @@ export function loadSearchableArtifactsForDir(researchDir) {
             atomicWriteFile(indexPath, JSON.stringify({ version: INDEX_VERSION, entries }));
         }
         catch {
-            // Best-effort cache write; search results are already computed without it.
+            // Best-effort cache write; results are already computed without it.
         }
     }
     return results;
@@ -93,11 +93,11 @@ export function loadSearchableArtifactsForDir(researchDir) {
  * key so a project entry shadows the same key in the global cache. Mirrors the dedup semantics of
  * {@link scanCacheDirs} but reads through the per-root sidecar index.
  */
-export function loadSearchableArtifacts(dataDirs) {
+export function loadIndexedArtifacts(dataDirs) {
     const seen = new Set();
     const all = [];
     for (const dataDir of dataDirs) {
-        for (const located of loadSearchableArtifactsForDir(join(dataDir, 'research'))) {
+        for (const located of loadIndexedArtifactsForDir(join(dataDir, 'research'))) {
             const key = located.artifact.metadata.cache_key;
             if (seen.has(key))
                 continue;

package/dist/lib/research/browser.d.ts

@@ -25,14 +25,6 @@ export declare class CdpClient {
 }
 export declare function findChromePath(): string;
 export declare function waitForLoad(client: CdpClient, sessionId: string, timeoutMs: number, settleMs?: number): Promise<void>;
-/**
- * Polls until a content-container element holds enough RENDERED text, so SPAs that fetch their
- * body after load are captured rendered rather than as a "Loading…" shell. Pierces open shadow
- * roots (the container is matched across shadow boundaries) and measures `innerText`, which
- * reflects shadow-rendered text — `document.querySelector` + `textContent` miss both. Returns
- * without throwing on timeout; the caller captures whatever rendered and judges its quality.
- */
-export declare function waitForContentReady(page: CdpPage, selectors: string[], minChars: number, timeoutMs: number): Promise<void>;
 export declare const BLOCKED_ASSET_URLS: string[];
 export interface CdpPage {
     client: CdpClient;

package/dist/lib/research/browser.js

@@ -164,48 +164,6 @@ export async function waitForLoad(client, sessionId, timeoutMs, settleMs = 1000)
     }
     throw new Error(`Navigation timed out after ${timeoutMs}ms`);
 }
-/**
- * Polls until a content-container element holds enough RENDERED text, so SPAs that fetch their
- * body after load are captured rendered rather than as a "Loading…" shell. Pierces open shadow
- * roots (the container is matched across shadow boundaries) and measures `innerText`, which
- * reflects shadow-rendered text — `document.querySelector` + `textContent` miss both. Returns
- * without throwing on timeout; the caller captures whatever rendered and judges its quality.
- */
-export async function waitForContentReady(page, selectors, minChars, timeoutMs) {
-    // Reports whether a content container has rendered (innerText pierces shadow), plus the total
-    // rendered text length so the caller can wait for the render to *settle* — heavy pages (e.g.
-    // the api-console) render the container early but keep filling it in.
-    const expression = `(() => {
-    const out = [];
-    const visit = (r) => { for (const c of Array.from(r.children || [])) { out.push(c); if (c.shadowRoot) visit(c.shadowRoot); visit(c); } };
-    visit(document);
-    const SELS = ${JSON.stringify(selectors)};
-    let has = false;
-    for (const el of out) {
-      if (!el.matches) continue;
-      if (!SELS.some((s) => { try { return el.matches(s); } catch (e) { return false; } })) continue;
-      if (((el.innerText) || '').trim().length >= ${minChars}) { has = true; break; }
-    }
-    return { has, len: document.body ? (document.body.innerText || '').length : 0 };
-  })()`;
-    const start = Date.now();
-    let previousLength = -1;
-    let stablePolls = 0;
-    while (Date.now() - start < timeoutMs) {
-        const value = (await page.client
-            .send('Runtime.evaluate', { expression, returnByValue: true }, page.sessionId)
-            .catch(() => null))?.result?.value;
-        if (value?.has) {
-            const grew = Math.abs((value.len || 0) - previousLength) > Math.max(40, previousLength * 0.02);
-            if (!grew && ++stablePolls >= 2)
-                return; // content present and rendering has settled
-            if (grew)
-                stablePolls = 0;
-            previousLength = value.len || 0;
-        }
-        await new Promise((r) => setTimeout(r, 500));
-    }
-}
 export const BLOCKED_ASSET_URLS = [
     '*.css',
     '*.png',
@@ -336,7 +294,13 @@ export class ResponseCapture {
         });
     }
 }
-export async function fetchRenderedHtml(url, options = {}) {
+// Chrome can emit these on first navigation in headless CI when the cert verifier reloads mid-run.
+const TRANSIENT_NAV_ERROR_CODES = ['ERR_CERT_VERIFIER_CHANGED'];
+function isTransientBrowserNavigationError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return TRANSIENT_NAV_ERROR_CODES.some((code) => message.includes(code));
+}
+async function fetchRenderedHtmlOnce(url, options = {}) {
     const timeout = options.timeoutMs ?? 15_000;
     const limit = options.bodyLimitBytes ?? 2 * 1024 * 1024;
     const currentUrl = normalizeUrl(url);
@@ -394,3 +358,16 @@ export async function fetchRenderedHtml(url, options = {}) {
         await page.close();
     }
 }
+export async function fetchRenderedHtml(url, options = {}) {
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fetchRenderedHtmlOnce(url, options);
+        }
+        catch (err) {
+            if (attempt === maxAttempts || !isTransientBrowserNavigationError(err))
+                throw err;
+        }
+    }
+    throw new Error('Failed to fetch rendered HTML after transient browser navigation errors.');
+}

package/dist/lib/research/regression.d.ts

@@ -15,6 +15,24 @@ export interface ContentMetrics {
     bullets: number;
     headings: number;
 }
+/** Maximum allowed capture-duration regression vs baseline (percent slower). */
+export declare const TIMING_REGRESSION_LIMIT_PCT = 25;
+export interface TimingRegression {
+    deltaPct: number | null;
+    regressed: boolean;
+}
+/** Returns whether `currentMs` exceeds baseline by more than TIMING_REGRESSION_LIMIT_PCT. */
+export declare function timingRegression(currentMs: number, baselineMs: number | null | undefined): TimingRegression;
+export interface TimingBaselineRecord {
+    durationMs: number;
+    capturedAt: string;
+}
+/** Parses a committed `baseline/<id>.timing.json` file. */
+export declare function parseTimingBaseline(raw: string): TimingBaselineRecord | null;
+/** Serializes a timing baseline record for `baseline/<id>.timing.json`. */
+export declare function formatTimingBaseline(durationMs: number, capturedAt?: string): string;
+/** True when `candidate` carries strictly more structural content than `baseline`. */
+export declare function contentRicherThan(candidate: ContentMetrics, baseline: ContentMetrics): boolean;
 /**
  * Structural content signals used to catch information loss between baseline and current output:
  * a sudden drop in code blocks, tables, images, or steps flags that a fetch change dropped content.

package/dist/lib/research/regression.js

@@ -38,6 +38,53 @@ export function normalizeRegressionMarkdown(markdown) {
         .replace(/\n{3,}/g, '\n\n')
         .trim();
 }
+/** Maximum allowed capture-duration regression vs baseline (percent slower). */
+export const TIMING_REGRESSION_LIMIT_PCT = 25;
+/** Returns whether `currentMs` exceeds baseline by more than TIMING_REGRESSION_LIMIT_PCT. */
+export function timingRegression(currentMs, baselineMs) {
+    if (!baselineMs || baselineMs <= 0)
+        return { deltaPct: null, regressed: false };
+    const deltaPct = Number((((currentMs - baselineMs) / baselineMs) * 100).toFixed(2));
+    return { deltaPct, regressed: deltaPct > TIMING_REGRESSION_LIMIT_PCT };
+}
+/** Parses a committed `baseline/<id>.timing.json` file. */
+export function parseTimingBaseline(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.durationMs !== 'number' || parsed.durationMs <= 0)
+            return null;
+        return {
+            durationMs: parsed.durationMs,
+            capturedAt: typeof parsed.capturedAt === 'string' ? parsed.capturedAt : '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Serializes a timing baseline record for `baseline/<id>.timing.json`. */
+export function formatTimingBaseline(durationMs, capturedAt = new Date().toISOString()) {
+    return `${JSON.stringify({ durationMs, capturedAt }, null, 2)}\n`;
+}
+/** Structural signals compared before char count when picking DOM vs API Markdown. */
+const CONTENT_RICHNESS_KEYS = [
+    'tables',
+    'codeBlocks',
+    'headings',
+    'images',
+    'orderedSteps',
+    'chars',
+];
+/** True when `candidate` carries strictly more structural content than `baseline`. */
+export function contentRicherThan(candidate, baseline) {
+    for (const key of CONTENT_RICHNESS_KEYS) {
+        if (candidate[key] > baseline[key])
+            return true;
+        if (candidate[key] < baseline[key])
+            return false;
+    }
+    return false;
+}
 /**
  * Structural content signals used to catch information loss between baseline and current output:
  * a sudden drop in code blocks, tables, images, or steps flags that a fetch change dropped content.

package/dist/lib/research/storage.d.ts

@@ -1,5 +1,4 @@
 import type { ResearchArtifact } from './schema.js';
-export declare function isResearchFile(file: string): boolean;
 /**
  * Scans a cache directory and maps each valid artifact file through a callback.
  * Return null from the callback to skip an entry; all non-null results are collected.

package/dist/lib/research/storage.js

@@ -2,12 +2,8 @@ import { join } from 'node:path';
 import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, renameSync, } from 'node:fs';
 import { atomicWriteFile } from '../atomic-write.js';
 import { parseArtifact, serializeArtifact } from './artifact.js';
-export function isResearchFile(file) {
-    return (file.endsWith('.md') &&
-        !file.includes('.tmp') &&
-        !file.includes('.corrupt') &&
-        !file.includes('.superseded'));
-}
+import { loadIndexedArtifactsForDir } from './artifact-index.js';
+import { isResearchFile } from './url.js';
 /**
  * Scans a cache directory and maps each valid artifact file through a callback.
  * Return null from the callback to skip an entry; all non-null results are collected.
@@ -169,11 +165,17 @@ export function locateArtifact(dataDirs, key) {
  */
 export function scanCacheDirs(dataDirs, fn) {
     const seen = new Set();
-    return dataDirs.flatMap((dataDir) => scanCacheDir(join(dataDir, 'research'), (artifact, filePath) => {
-        const key = artifact.metadata.cache_key;
-        if (seen.has(key))
-            return null;
-        seen.add(key);
-        return fn(artifact, filePath);
-    }));
+    return dataDirs.flatMap((dataDir) => {
+        const researchDir = join(dataDir, 'research');
+        const searchable = loadIndexedArtifactsForDir(researchDir);
+        return searchable
+            .map(({ artifact, filePath }) => {
+            const key = artifact.metadata.cache_key;
+            if (seen.has(key))
+                return null;
+            seen.add(key);
+            return fn(artifact, filePath);
+        })
+            .filter((x) => x !== null);
+    });
 }

package/dist/lib/research/url.d.ts

@@ -17,8 +17,30 @@ export declare function isSafeIp(ip: string): boolean;
  * Validates a hostname to ensure it is not blocked (e.g. localhost or literal private IP).
  */
 export declare function validateHostname(hostname: string): void;
+/**
+ * Whether the input looks like a URL that simply forgot its `http(s)://` scheme
+ * (`example.com`, `docs.nestjs.com/guide`, `192.168.1.1`) rather than unparseable junk.
+ * Lets every command turn a scheme-less URL into the same actionable "did you mean https://…" hint
+ * that the root `bonsai <url>` shorthand already gives via the command_not_found hook.
+ */
+export declare function looksLikeSchemelessUrl(input: string): boolean;
 /**
  * Parses and normalizes a URL. Strips fragments, credentials, default ports,
  * and sorts query parameters lexicographically.
  */
 export declare function normalizeUrl(input: string): string;
+/**
+ * Checks if a URL matches a wildcard pattern (case-insensitive, supports * wildcard).
+ */
+export declare function matchesUrlGlob(url: string, glob: string): boolean;
+/**
+ * Checks if artifact metadata contains any URL matching the filter glob.
+ */
+export declare function artifactMatchesUrlFilter(meta: {
+    source_urls?: string[];
+    source_url?: string;
+}, filterUrl: string | undefined): boolean;
+/**
+ * Checks if a filename matches the standard research note naming pattern.
+ */
+export declare function isResearchFile(file: string): boolean;

package/dist/lib/research/url.js

@@ -83,6 +83,30 @@ export function validateHostname(hostname) {
         }
     }
 }
+// Dot-separated, non-empty labels: a real domain (`docs.nestjs.com`) or IPv4 (`192.168.1.1`). The
+// URL parser also accepts a leading-dot filename (`.env`) or relative path (`./x`) as a "host", whose
+// suggestion would be a nonsense `https://.env`; requiring well-formed labels rejects those. Anchored
+// with no overlapping quantifiers, so it is ReDoS-safe on the (already length-bounded) host. This is
+// the single owner of the domain-shape test; the command_not_found hook consumes it too.
+const DOMAIN_OR_IPV4 = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/i;
+/**
+ * Whether the input looks like a URL that simply forgot its `http(s)://` scheme
+ * (`example.com`, `docs.nestjs.com/guide`, `192.168.1.1`) rather than unparseable junk.
+ * Lets every command turn a scheme-less URL into the same actionable "did you mean https://…" hint
+ * that the root `bonsai <url>` shorthand already gives via the command_not_found hook.
+ */
+export function looksLikeSchemelessUrl(input) {
+    if (input.includes('://'))
+        return false;
+    let hostname;
+    try {
+        hostname = new URL(`https://${input}`).hostname;
+    }
+    catch {
+        return false;
+    }
+    return DOMAIN_OR_IPV4.test(hostname);
+}
 /**
  * Parses and normalizes a URL. Strips fragments, credentials, default ports,
  * and sorts query parameters lexicographically.
@@ -95,7 +119,12 @@ export function normalizeUrl(input) {
     catch {
         // new URL() only ever throws the constant "Invalid URL" (no structured cause worth keeping),
         // and every caller prefixes its own "Invalid URL:" — forwarding the native text would stutter.
-        // Drop the binding and emit an actionable, self-contained reason instead.
+        // A scheme-less but domain-shaped input is the common "forgot https://" mistake, so steer the
+        // user to the corrected URL (clig.dev: show the fix, never auto-run it); otherwise emit a
+        // self-contained "couldn't parse" reason.
+        if (looksLikeSchemelessUrl(input)) {
+            throw new Error(`"${input}" is missing a URL scheme. Did you mean https://${input}? Only http:// and https:// URLs are supported.`);
+        }
         throw new Error(`Could not parse "${input}" as a URL; provide a full http(s) URL like https://example.com/page.`);
     }
     if (url.protocol !== 'http:' && url.protocol !== 'https:') {
@@ -122,3 +151,36 @@ export function normalizeUrl(input) {
     url.search = new URLSearchParams(params).toString();
     return url.toString();
 }
+/**
+ * Checks if a URL matches a wildcard pattern (case-insensitive, supports * wildcard).
+ */
+export function matchesUrlGlob(url, glob) {
+    // Collapse consecutive wildcards to prevent ReDoS
+    const collapsedGlob = glob.replace(/\*+/g, '*');
+    const normalizedGlob = collapsedGlob.toLowerCase();
+    const normalizedUrl = url.toLowerCase();
+    // Escape regex characters except *
+    const escapedGlob = normalizedGlob.replace(/[/\-\\^$+?.()|[\]{}]/g, '\\$&');
+    // Replace * with .*
+    const regexString = '^' + escapedGlob.replace(/\*/g, '.*') + '$';
+    const regex = new RegExp(regexString);
+    return regex.test(normalizedUrl);
+}
+/**
+ * Checks if artifact metadata contains any URL matching the filter glob.
+ */
+export function artifactMatchesUrlFilter(meta, filterUrl) {
+    if (!filterUrl)
+        return true;
+    const urls = meta.source_urls || (meta.source_url ? [meta.source_url] : []);
+    return urls.some((u) => matchesUrlGlob(u, filterUrl));
+}
+/**
+ * Checks if a filename matches the standard research note naming pattern.
+ */
+export function isResearchFile(file) {
+    return (file.endsWith('.md') &&
+        !file.includes('.tmp') &&
+        !file.includes('.corrupt') &&
+        !file.includes('.superseded'));
+}

package/dist/lib/text.d.ts

@@ -22,9 +22,11 @@ export declare function resultListHeading(total: number, shown: number, labels:
  * stdout heading is suppressed and an agent would otherwise get no signal that results were capped.
  */
 export declare function truncationNotice(total: number, shown: number, labels: ResultListLabels): string | null;
+/** Max edit distance for a plausible typo; scales with input length. */
+export declare function maxFuzzyDistance(input: string): number;
 /**
  * Levenshtein edit distance: the minimum number of single-character insertions, deletions, or
- * substitutions to turn `s1` into `s2`. Shared by fuzzy search ranking and command-typo suggestion.
+ * substitutions to turn `s1` into `s2`. Shared by command-typo suggestion.
  */
 export declare function levenshtein(s1: string, s2: string): number;
 /**

package/dist/lib/text.js

@@ -24,9 +24,17 @@ export function truncationNotice(total, shown, labels) {
         return null;
     return `${total} entries matched; returning the ${labels.order} ${shown}. Raise --limit (max ${labels.maxLimit}) to see more.`;
 }
+/** Max edit distance for a plausible typo; scales with input length. */
+export function maxFuzzyDistance(input) {
+    if (input.length <= 3)
+        return 1;
+    if (input.length <= 5)
+        return 2;
+    return 3;
+}
 /**
  * Levenshtein edit distance: the minimum number of single-character insertions, deletions, or
- * substitutions to turn `s1` into `s2`. Shared by fuzzy search ranking and command-typo suggestion.
+ * substitutions to turn `s1` into `s2`. Shared by command-typo suggestion.
  */
 export function levenshtein(s1, s2) {
     if (s1.length < s2.length)

package/dist/sites/coveo.d.ts

@@ -0,0 +1,7 @@
+export declare const ALLOWED_DOC_HOSTS: Set<string>;
+export declare function isAllowedDocHost(hostname: string): boolean;
+/**
+ * Coveo indexes Help articles under an internal `/help_doccontent` URL; rewrite it to the
+ * canonical `/s/articleView` page a human (or our fetcher) can actually open.
+ */
+export declare function normalizeHelpDocContentUrl(rawUrl: string): string;

package/dist/sites/coveo.js

@@ -0,0 +1,33 @@
+export const ALLOWED_DOC_HOSTS = new Set(['help.salesforce.com', 'developer.salesforce.com']);
+export function isAllowedDocHost(hostname) {
+    return ALLOWED_DOC_HOSTS.has(hostname.toLowerCase());
+}
+/**
+ * Coveo indexes Help articles under an internal `/help_doccontent` URL; rewrite it to the
+ * canonical `/s/articleView` page a human (or our fetcher) can actually open.
+ */
+export function normalizeHelpDocContentUrl(rawUrl) {
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        return rawUrl;
+    }
+    if (url.hostname.toLowerCase() !== 'help.salesforce.com')
+        return rawUrl;
+    if (!url.pathname.toLowerCase().startsWith('/help_doccontent'))
+        return rawUrl;
+    const id = url.searchParams.get('id');
+    if (!id)
+        return rawUrl;
+    const articleUrl = new URL('https://help.salesforce.com/s/articleView');
+    articleUrl.searchParams.set('id', id.endsWith('.htm') ? id : `${id}.htm`);
+    articleUrl.searchParams.set('type', '5');
+    for (const key of ['release', 'language']) {
+        const value = url.searchParams.get(key);
+        if (value)
+            articleUrl.searchParams.set(key, value);
+    }
+    return articleUrl.toString();
+}

package/dist/sites/index.js

@@ -1,27 +1,10 @@
 import { salesforce } from './salesforce/index.js';
 import { salesforceDeveloper } from './salesforce-developer/index.js';
-import { nextjs } from './nextjs/index.js';
-import { react, vue, tailwind, jest, cypress, vitest, vitepress } from './algolia.js';
-import { angular, redux, vite, fastify, rollup, vueuse } from './auto.js';
 // The known documentation sites. A plain constant, not a registry: these ship
 // with the CLI, so there is nothing to register at runtime. Sites with custom
-// fetch/search behavior live in their own module (e.g. ./salesforce). Salesforce Help and
+// fetch behavior live in their own module (e.g. ./salesforce). Salesforce Help and
 // Salesforce Developer are separate modules — different domains, different extraction.
 export const SITES = [
-    react,
-    vue,
-    tailwind,
-    nextjs,
-    jest,
-    cypress,
-    vitest,
-    vitepress,
-    angular,
-    redux,
-    vite,
-    fastify,
-    rollup,
-    vueuse,
     salesforce,
     salesforceDeveloper,
     // TanStack docs embed a GitHub "edit this page" link, so capture resolves the page's source

package/dist/sites/salesforce/fetch-page.js

@@ -1,5 +1,5 @@
 import { fetchSalesforceDoc } from '../salesforce-doc-fetch.js';
-import { normalizeHelpDocContentUrl } from './coveo.js';
+import { normalizeHelpDocContentUrl } from '../coveo.js';
 // Containers a Help article renders into (inside shadow DOM); the shared fetcher pierces
 // shadow roots to find them, falling back to the page body when none match.
 const CONTENT_SELECTORS = [

package/dist/sites/salesforce/index.js

@@ -1,16 +1,11 @@
 import { fetchSalesforcePage } from './fetch-page.js';
-import { searchSalesforce } from './browser-search.js';
-// Scoped to help.salesforce.com — an LWR Experience site with light-DOM article content and
-// Coveo (HTCommunity) search. developer.salesforce.com is intentionally NOT routed here: its
-// API-reference docs render inside shadow DOM with tabbed/code content that needs a different
-// extraction strategy, so it belongs in its own module when built — not bolted onto this one.
-// (developer.salesforce.com URLs that appear in Help search results are still surfaced; see
-// ALLOWED_DOC_HOSTS in coveo.ts.)
+// Scoped to help.salesforce.com — an LWR Experience site with light-DOM article content.
+// developer.salesforce.com is intentionally NOT routed here: its API-reference docs render
+// inside shadow DOM with tabbed/code content that needs a different extraction strategy.
 export const salesforce = {
     id: 'salesforce',
     name: 'Salesforce Help',
     domains: ['help.salesforce.com'],
     defaults: { rendered: true },
     fetchPage: fetchSalesforcePage,
-    search: searchSalesforce,
 };

package/dist/sites/salesforce-developer/fetch-page.js

@@ -2,8 +2,10 @@ import { fetchSalesforceDoc } from '../salesforce-doc-fetch.js';
 // Containers a developer doc renders into. doc-content-layout / doc-amf-reference are the
 // web-component hosts for guide pages and API-reference (AMF) pages respectively.
 const CONTENT_SELECTORS = [
-    'doc-content-layout',
+    // API-reference pages: doc-amf-reference holds the method/type tables. doc-content-layout only
+    // carries the shared deprecation banner and must not win selector priority on those pages.
     'doc-amf-reference',
+    'doc-content-layout',
     '.markdown-content',
     'main article',
     'article',

package/dist/sites/salesforce-developer/index.js

@@ -1,8 +1,7 @@
 import { fetchDeveloperPage } from './fetch-page.js';
 // developer.salesforce.com docs (guides + API reference) render client-side inside web
 // components, so content lives in shadow DOM — a fundamentally different extraction strategy
-// than help.salesforce.com (see ../salesforce). No `search`: developer docs use a separate
-// search backend, not Help's Coveo HTCommunity hub.
+// than help.salesforce.com (see ../salesforce).
 export const salesforceDeveloper = {
     id: 'salesforce-developer',
     name: 'Salesforce Developer',

package/dist/sites/salesforce-doc-fetch.d.ts

@@ -2,6 +2,17 @@ import type { SiteFetchResult } from './types.js';
 /** True when the extracted text is an error/not-found/loading shell rather than real content. */
 export declare function looksLikeSalesforceError(text: string): boolean;
 export declare function stripBoilerplate(markdown: string): string;
+/** Parses the Salesforce private content API JSON payload. */
+export declare function parseDocsApiPayload(raw: string): {
+    content: string;
+    title: string;
+} | null;
+/** Keeps whichever Markdown source carries more structural content (DOM vs content API HTML). */
+export declare function preferRicherMarkdown(domMarkdown: string, apiHtml: string, domTitle: string, apiTitle: string): {
+    markdown: string;
+    title: string;
+    usedApi: boolean;
+};
 export interface SalesforceDocOptions {
     allowedHost: string;
     contentSelectors: string[];