@intlayer/engine 9.5.10 → 9.5.12

package/dist/types/scan/detection/localeCode.d.ts

@@ -0,0 +1,49 @@
+//#region src/scan/detection/localeCode.d.ts
+/**
+ * Locale-code helpers shared by the scan checks and the routing detection.
+ *
+ * Dependency-free and browser-safe: consumed by the CLI, the backend audit and
+ * the Chrome extension popup.
+ */
+/** Lower-case a locale code and use `-` as separator (`pt_BR` → `pt-br`). */
+export declare const normalizeLocaleCode: (localeCode: string) => string;
+/** Primary language subtag of a locale code (`en-US` → `en`). */
+export declare const getLanguageCode: (localeCode: string) => string;
+/** Whether two locale codes designate the same locale, ignoring case/separator. */
+export declare const isSameLocale: (firstLocale: string | undefined, secondLocale: string | undefined) => boolean;
+/** Whether two locale codes share the same language (`fr` vs `fr-CA`). */
+export declare const isSameLanguage: (firstLocale: string | undefined, secondLocale: string | undefined) => boolean;
+/** Whether a string looks like a locale code (used on URL segments). */
+export declare const looksLikeLocaleCode: (value: string) => boolean;
+/**
+ * Whether a locale code is a valid BCP 47 tag (`en_US` and `english` are not).
+ * `x-default` is accepted since it is a valid hreflang value.
+ */
+export declare const isValidLocaleCode: (localeCode: string) => boolean;
+/** Whether the locale is written right-to-left (`ar`, `he-IL`, `fa`…). */
+export declare const isRightToLeftLocale: (localeCode: string) => boolean;
+/**
+ * Find, among `candidateLocales`, the one matching `value` (a URL segment, a
+ * subdomain label or a query-string value). Falls back to a language-only match
+ * when no exact match exists (`/fr/` for hreflang `fr-FR`).
+ */
+export declare const findMatchingLocale: (value: string | undefined | null, candidateLocales: readonly string[]) => string | undefined;
+/**
+ * Whether a value is a valid `og:locale` (`en_GB`). Open Graph does not accept
+ * a bare language (`en`) nor BCP 47 separators (`en-GB`): crawlers then fall
+ * back to `en_US`.
+ */
+export declare const isValidOpenGraphLocale: (localeCode: string) => boolean;
+/**
+ * Suggest the `og:locale` value for a locale code. The region comes from the
+ * locale itself, then from `regionHint` (typically `<html lang>`) when it
+ * shares the language, then from the language's most likely region.
+ *
+ * @example
+ * toOpenGraphLocale('en', 'en-GB'); // 'en_GB'
+ * toOpenGraphLocale('pt-br'); // 'pt_BR'
+ * toOpenGraphLocale('fr'); // 'fr_FR'
+ */
+export declare const toOpenGraphLocale: (localeCode: string, regionHint?: string) => string | undefined;
+//#endregion
+//# sourceMappingURL=localeCode.d.ts.map

package/dist/types/scan/detection/localeCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localeCode.d.ts","names":[],"sources":["../../../../src/scan/detection/localeCode.ts"],"mappings":";;;;;;;;qBA8Ba,sBAAmB;;qBAInB,kBAAe;;qBAIf,eAAY,iCACQ;;qBASpB,iBAAc,iCACM;;qBAQpB,sBAAmB;;;;;qBAOnB,oBAAiB;;qBAajB,sBAAmB;;;;;;qBAQnB,qBAAkB,kCACG;;;;;;qBAyBrB,yBAAsB;;;;;;;;;;;qBA+BtB,oBAAiB,oBACV"}

package/dist/types/scan/detection/localizedPages.d.ts

@@ -0,0 +1,40 @@
+import { RoutingDetection } from "./detectRoutingStrategy.js";
+//#region src/scan/detection/localizedPages.d.ts
+/** A localized version of a page, read from its hreflang tags. */
+export type LocalizedPage = {
+  hreflang: string;
+  /** Absolute URL of the localized version. */
+  url: string;
+  /** True when this alternate points to the page currently inspected. */
+  isCurrent: boolean;
+};
+/**
+ * Turns the hreflang alternates of a page into a navigable list: absolute,
+ * deduped by URL (a real locale wins over `x-default`), flagging the current
+ * page, `x-default` last.
+ *
+ * @param hreflangs - `<link rel="alternate" hreflang>` entries of the page.
+ * @param currentUrl - Absolute URL of the page, used to resolve relative hrefs.
+ */
+export declare const getLocalizedPages: (hreflangs: {
+  hreflang: string;
+  href: string;
+}[], currentUrl: string) => LocalizedPage[];
+/** Input of {@link isBaseLocalePage}. */
+export type BaseLocalePageInput = {
+  pageUrl: string;
+  hreflangs: {
+    hreflang: string;
+    href: string;
+  }[];
+  routing: Pick<RoutingDetection, 'strategy' | 'locales' | 'urlLocale' | 'defaultLocale'>;
+};
+/**
+ * Whether the page is the base (unlocalized / default-locale entry) version of
+ * a multilingual page: the `x-default` target, the root of a `prefix-all`
+ * site, or the unmarked default-locale URL. i18n issues tend to hide on the
+ * localized versions rather than on this one.
+ */
+export declare const isBaseLocalePage: ({ pageUrl, hreflangs, routing }: BaseLocalePageInput) => boolean;
+//#endregion
+//# sourceMappingURL=localizedPages.d.ts.map

package/dist/types/scan/detection/localizedPages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localizedPages.d.ts","names":[],"sources":["../../../../src/scan/detection/localizedPages.ts"],"mappings":";;;YAKY;EACV;;EAEA;;EAEA;;;;;;;;;;qBAaW,oBAAiB;EACf;EAAkB;KAAgB,uBAE9C;;YA4BS;EACV;EACA;IAAa;IAAkB;;EAC/B,SAAS,KACP;;;;;;;;qBAWS,qBAAgB,SAAA,WAAA,WAI1B"}

package/dist/types/scan/detection/technologySignatures.d.ts

@@ -0,0 +1,48 @@
+//#region src/scan/detection/technologySignatures.d.ts
+/**
+ * Category of a technology detected on a scanned page.
+ *
+ * - `framework`: rendering framework (Next.js, Nuxt, Angular…)
+ * - `i18n-library`: code-level i18n library (Intlayer, i18next, vue-i18n…)
+ * - `tms`: translation management system (Crowdin, Phrase, Lokalise…)
+ * - `translation-proxy`: hosted website translation layer (Weglot, Localize…)
+ * - `cms`: content management system / site builder
+ */
+export type TechnologyCategory = 'framework' | 'i18n-library' | 'tms' | 'translation-proxy' | 'cms';
+/**
+ * Fingerprint of a technology. Every signal is optional; a technology is
+ * detected as soon as one of them matches. Regexes with a first capture group
+ * provide the detected version.
+ */
+export type TechnologySignature = {
+  /** Stable identifier, e.g. `nextjs`, `crowdin`. */
+  id: string;
+  /** Human-readable name. */
+  name: string;
+  category: TechnologyCategory;
+  /** Matched against script / stylesheet / iframe / request URLs. */
+  resourceUrls?: RegExp[];
+  /** Matched against the HTML document, inline scripts included. */
+  html?: RegExp[];
+  /** Matched against the content of same-origin JavaScript chunks. */
+  bundle?: RegExp[];
+  /** Window globals, only available when inspecting a live page. */
+  globals?: string[];
+  /** Cookie / localStorage / sessionStorage keys (case-insensitive). */
+  storageKeys?: string[];
+  /**
+   * Markers only a live DOM exposes, reported by the collector (e.g.
+   * `react-fiber` for the `__reactFiber$…` keys React sets on elements).
+   */
+  domMarkers?: string[];
+  /** Dotted window path holding the version, e.g. `next.version`. */
+  versionGlobal?: string;
+  /** Only reported when every one of these ids is detected too. */
+  requires?: string[];
+  /** Hidden when any of these ids is detected (e.g. Vue under Nuxt). */
+  hiddenBy?: string[];
+};
+/** Every known technology fingerprint, in display order. */
+export declare const technologySignatures: readonly TechnologySignature[];
+//#endregion
+//# sourceMappingURL=technologySignatures.d.ts.map

package/dist/types/scan/detection/technologySignatures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"technologySignatures.d.ts","names":[],"sources":["../../../../src/scan/detection/technologySignatures.ts"],"mappings":";;;;;;;;;;YASY;;;;;;YAYA;;EAEV;;EAEA;EACA,UAAU;;EAEV,eAAe;;EAEf,OAAO;;EAEP,SAAS;;EAET;;EAEA;;;;;EAKA;;EAEA;;EAEA;;EAEA;;;qBAwkBW,+BAA+B"}

package/dist/types/scan/detection/url.d.ts

@@ -0,0 +1,27 @@
+//#region src/scan/detection/url.d.ts
+/** URL helpers shared by the scan checks (browser-safe). */
+/** Parse a possibly relative URL, returning `undefined` when it is invalid. */
+export declare const parseUrl: (url: string, baseUrl?: string) => URL | undefined;
+/** Strip a leading `www.` so `www.example.com` and `example.com` compare equal. */
+export declare const normalizeHostname: (hostname: string) => string;
+/**
+ * Canonical comparable form of a URL: no hash, no trailing slash (except the
+ * root), `www.` stripped. Returns the input unchanged when it cannot be parsed.
+ */
+export declare const normalizeUrl: (url: string, baseUrl?: string) => string;
+/** First non-empty segment of a URL path (`/fr/about` → `fr`). */
+export declare const getFirstPathSegment: (pathname: string) => string | undefined;
+/**
+ * Whether the URL is fully qualified (`https://host/…`), as hreflang requires.
+ * Relative (`/fr`), protocol-relative (`//host/fr`) and non-HTTP URLs are not.
+ */
+export declare const isAbsoluteUrl: (url: string) => boolean;
+/**
+ * Approximate registrable domain of a hostname (`gtm.crowdin.com` →
+ * `crowdin.com`, `www.airbnb.co.uk` → `airbnb.co.uk`), without a public
+ * suffix list: a short second-level label under a country code is treated as
+ * part of the suffix.
+ */
+export declare const getSiteDomain: (hostname: string) => string;
+//#endregion
+//# sourceMappingURL=url.d.ts.map

package/dist/types/scan/detection/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","names":[],"sources":["../../../../src/scan/detection/url.ts"],"mappings":";;;qBAGa,WAAQ,aAAe,qBAAqB;;qBAS5C,oBAAiB;;;;;qBAOjB,eAAY,aAAe;;qBAa3B,sBAAmB;;;;;qBAOnB,gBAAa;;;;;;;qBASb,gBAAa"}

package/dist/types/scan/fetchText.d.ts

@@ -0,0 +1,30 @@
+//#region src/scan/fetchText.d.ts
+/** Options shared by every network request issued during a scan. */
+export type ScanFetchOptions = {
+  userAgent: string;
+  timeoutMs: number;
+  /**
+   * Guard called before fetching any URL discovered on the scanned site
+   * (hreflang alternates, sitemap children…). The hosted audit uses it to
+   * block private / reserved addresses (SSRF). Defaults to allowing all.
+   */
+  shouldFetchUrl?: (url: string) => boolean | Promise<boolean>;
+};
+/** Response of {@link fetchText}. */
+export type FetchTextResult = {
+  status: number;
+  ok: boolean;
+  text: string;
+  /** URL after redirects. */
+  finalUrl: string;
+  /** Whether at least one redirect was followed. */
+  redirected: boolean;
+};
+/**
+ * GET a URL as text with a timeout, returning `undefined` when the request is
+ * blocked by {@link ScanFetchOptions.shouldFetchUrl} or fails at network level.
+ * Redirects are followed manually so every hop goes through the guard.
+ */
+export declare const fetchText: (url: string, { userAgent, timeoutMs, shouldFetchUrl }: ScanFetchOptions) => Promise<FetchTextResult | undefined>;
+//#endregion
+//# sourceMappingURL=fetchText.d.ts.map

package/dist/types/scan/fetchText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchText.d.ts","names":[],"sources":["../../../src/scan/fetchText.ts"],"mappings":";;YACY;EACV;EACA;;;;;;EAMA,kBAAkB,0BAA0B;;;YAIlC;EACV;EACA;EACA;;EAEA;;EAEA;;;;;;;qBAyBW,YAAS,eACT,WAAA,WAAA,kBAC+B,qBACzC,QAAQ"}

package/dist/types/scan/index.d.ts

@@ -1,7 +1,19 @@
 import { ScorableEvent, Score, ScoreCheckType, mutateScore, scoreRecord, toScorePercent } from "./calculateScore.js";
-import { BundleChunkInput, BundleContentAnalysis, ChunkAnalysis, ScanCheckStatus, ScanEvent, ScanEventDetails, ScanMode, ScanOptions, ScanResult } from "./types.js";
+import { RoutingDetection, RoutingDetectionInput, RoutingStrategy, detectRoutingStrategy, getUrlLocale } from "./detection/detectRoutingStrategy.js";
+import { TechnologyCategory, TechnologySignature, technologySignatures } from "./detection/technologySignatures.js";
+import { DetectedTechnology, TechnologyDetectionInput, detectTechnologies, getTechnologyGlobalNames } from "./detection/detectTechnologies.js";
+import { BundleChunkInput, BundleContentAnalysis, ChunkAnalysis, PageMetadata, ScanCheckStatus, ScanEvent, ScanEventDetails, ScanMode, ScanOptions, ScanResult } from "./types.js";
 import { analyzeBundleContent } from "./analyzeBundleContent.js";
-import { Anchor, HreflangLink, byteLength, extractAnchors, extractHreflangs, extractHtmlDir, extractHtmlLang, extractMetaDescription, extractOgImage, extractScriptUrls, extractTitle, extractVisibleTextStrings, hasCanonical } from "./parseHtml.js";
-import { checkBundleContent, checkCanonical, checkHtmlAttributes, checkLinguisticStructure, checkRobots, checkSitemap, checkUrlStructure, formatSize } from "./checks.js";
+import { FetchTextResult, ScanFetchOptions, fetchText } from "./fetchText.js";
+import { Anchor, HreflangLink, byteLength, extractAnchors, extractCanonicalHref, extractHreflangs, extractHtmlDir, extractHtmlLang, extractMetaDescription, extractOgImage, extractOgLocale, extractOgLocaleAlternates, extractResourceUrls, extractScriptUrls, extractTitle, extractVisibleTextStrings, hasCanonical } from "./parseHtml.js";
+import { EmitScanEvent, PageSignals, checkBundleContent, checkCanonical, checkHreflang, checkHreflangReciprocity, checkHtmlDir, checkHtmlLang, checkInternalLinks, checkLocaleConsistency, checkOgLocale, checkRobots, checkSitemap, checkXDefault, formatBundleAnalysis, formatSize } from "./checks.js";
+import { CheckDetailParts, getCheckDetailLines, splitCheckDetails } from "./detection/checkDetails.js";
+import { LinkAnchor, LinkClassification, LinkClassificationInput, classifyInternalLinks } from "./detection/classifyInternalLinks.js";
+import { findMatchingLocale, getLanguageCode, isRightToLeftLocale, isSameLanguage, isSameLocale, isValidLocaleCode, isValidOpenGraphLocale, looksLikeLocaleCode, normalizeLocaleCode, toOpenGraphLocale } from "./detection/localeCode.js";
+import { BaseLocalePageInput, LocalizedPage, getLocalizedPages, isBaseLocalePage } from "./detection/localizedPages.js";
+import { getFirstPathSegment, getSiteDomain, isAbsoluteUrl, normalizeHostname, normalizeUrl, parseUrl } from "./detection/url.js";
+import { ParsedRobots, isPathAllowedByRobots, parseRobots } from "./robots.js";
+import { RunScanChecksOptions, ScanChecksResult, ScanPageInfo, ScanPageInput, runScanChecks } from "./runScanChecks.js";
 import { scanWebsite } from "./scanWebsite.js";
-export { Anchor, BundleChunkInput, BundleContentAnalysis, ChunkAnalysis, HreflangLink, ScanCheckStatus, ScanEvent, ScanEventDetails, ScanMode, ScanOptions, ScanResult, ScorableEvent, Score, ScoreCheckType, analyzeBundleContent, byteLength, checkBundleContent, checkCanonical, checkHtmlAttributes, checkLinguisticStructure, checkRobots, checkSitemap, checkUrlStructure, extractAnchors, extractHreflangs, extractHtmlDir, extractHtmlLang, extractMetaDescription, extractOgImage, extractScriptUrls, extractTitle, extractVisibleTextStrings, formatSize, hasCanonical, mutateScore, scanWebsite, scoreRecord, toScorePercent };
+import { CollectedSitemaps, ParsedSitemap, SitemapEntry, collectSitemapEntries, discoverSitemapUrls, getDefaultSitemapUrls, parseSitemap } from "./sitemap.js";
+export { Anchor, BaseLocalePageInput, BundleChunkInput, BundleContentAnalysis, CheckDetailParts, ChunkAnalysis, CollectedSitemaps, DetectedTechnology, EmitScanEvent, FetchTextResult, HreflangLink, LinkAnchor, LinkClassification, LinkClassificationInput, LocalizedPage, PageMetadata, PageSignals, ParsedRobots, ParsedSitemap, RoutingDetection, RoutingDetectionInput, RoutingStrategy, RunScanChecksOptions, ScanCheckStatus, ScanChecksResult, ScanEvent, ScanEventDetails, ScanFetchOptions, ScanMode, ScanOptions, ScanPageInfo, ScanPageInput, ScanResult, ScorableEvent, Score, ScoreCheckType, SitemapEntry, TechnologyCategory, TechnologyDetectionInput, TechnologySignature, analyzeBundleContent, byteLength, checkBundleContent, checkCanonical, checkHreflang, checkHreflangReciprocity, checkHtmlDir, checkHtmlLang, checkInternalLinks, checkLocaleConsistency, checkOgLocale, checkRobots, checkSitemap, checkXDefault, classifyInternalLinks, collectSitemapEntries, detectRoutingStrategy, detectTechnologies, discoverSitemapUrls, extractAnchors, extractCanonicalHref, extractHreflangs, extractHtmlDir, extractHtmlLang, extractMetaDescription, extractOgImage, extractOgLocale, extractOgLocaleAlternates, extractResourceUrls, extractScriptUrls, extractTitle, extractVisibleTextStrings, fetchText, findMatchingLocale, formatBundleAnalysis, formatSize, getCheckDetailLines, getDefaultSitemapUrls, getFirstPathSegment, getLanguageCode, getLocalizedPages, getSiteDomain, getTechnologyGlobalNames, getUrlLocale, hasCanonical, isAbsoluteUrl, isBaseLocalePage, isPathAllowedByRobots, isRightToLeftLocale, isSameLanguage, isSameLocale, isValidLocaleCode, isValidOpenGraphLocale, looksLikeLocaleCode, mutateScore, normalizeHostname, normalizeLocaleCode, normalizeUrl, parseRobots, parseSitemap, parseUrl, runScanChecks, scanWebsite, scoreRecord, splitCheckDetails, technologySignatures, toOpenGraphLocale, toScorePercent };

package/dist/types/scan/parseHtml.d.ts

@@ -19,6 +19,12 @@ export declare const extractTitle: (html: string) => string;
 export declare const extractMetaDescription: (html: string) => string;
 /** Extract the `<meta property="og:image">` content. */
 export declare const extractOgImage: (html: string) => string | undefined;
+/** Extract the `<meta property="og:locale">` content. */
+export declare const extractOgLocale: (html: string) => string | undefined;
+/** Extract every `<meta property="og:locale:alternate">` content. */
+export declare const extractOgLocaleAlternates: (html: string) => string[];
+/** Extract the `href` of the `<link rel="canonical">` element, if present. */
+export declare const extractCanonicalHref: (html: string) => string | undefined;
 /** Whether a `<link rel="canonical">` element is present. */
 export declare const hasCanonical: (html: string) => boolean;
 /** A parsed `<link rel="alternate" hreflang>` element. */
@@ -41,9 +47,20 @@ export declare const extractScriptUrls: (html: string, baseUrl: string) => strin
 export type Anchor = {
   href: string;
   text: string;
+  /** `hreflang` attribute, set on language-switcher links. */
+  hreflang?: string;
 };
 /** Extract every `<a href="…">text</a>` anchor from the document. */
 export declare const extractAnchors: (html: string) => Anchor[];
+/**
+ * Extract every resource URL referenced by the document (`<script src>`,
+ * `<link href>`, `<iframe src>`), used to fingerprint third-party services.
+ *
+ * @param html - The raw HTML document.
+ * @param baseUrl - Base URL used to resolve relative URLs.
+ * @returns Absolute, de-duplicated URLs.
+ */
+export declare const extractResourceUrls: (html: string, baseUrl: string) => string[];
 /**
  * Extract visible text snippets from an HTML document (scripts, styles and
  * tags stripped). Used to approximate the rendered content size without a DOM.

package/dist/types/scan/parseHtml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseHtml.d.ts","names":[],"sources":["../../../src/scan/parseHtml.ts"],"mappings":";;;;;;;;;;qBAUa,aAAU;;qBAkBV,kBAAe;;qBAMf,iBAAc;;qBAMd,eAAY;;qBAMZ,yBAAsB;;qBAWtB,iBAAc;;qBAWd,eAAY;;YAMb;EAAiB;EAAkB;;;qBAGlC,mBAAgB,iBAAmB;;;;;;;;;qBAoBnC,oBAAiB,cAAgB;;YA4BlC;EAAW;EAAc;;;qBAGxB,iBAAc,iBAAmB;;;;;qBAsBjC,4BAAyB"}
+{"version":3,"file":"parseHtml.d.ts","names":[],"sources":["../../../src/scan/parseHtml.ts"],"mappings":";;;;;;;;;;qBAUa,aAAU;;qBAkBV,kBAAe;;qBAMf,iBAAc;;qBAMd,eAAY;;qBAMZ,yBAAsB;;qBAWtB,iBAAc;;qBAWd,kBAAe;;qBAWf,4BAAyB;;qBAYzB,uBAAoB;;qBAWpB,eAAY;;YAIb;EAAiB;EAAkB;;;qBAGlC,mBAAgB,iBAAmB;;;;;;;;;qBAoBnC,oBAAiB,cAAgB;;YA4BlC;EACV;EACA;;EAEA;;;qBAIW,iBAAc,iBAAmB;;;;;;;;;qBAgCjC,sBAAmB,cAClB;;;;;qBAyBD,4BAAyB"}

package/dist/types/scan/robots.d.ts

@@ -0,0 +1,23 @@
+//#region src/scan/robots.d.ts
+/** Rules of a `robots.txt` that apply to Google's crawler. */
+export type ParsedRobots = {
+  /** `Disallow` paths of the group applying to Googlebot (or `*`). */
+  disallowedPaths: string[];
+  /** `Allow` paths of the same group. */
+  allowedPaths: string[];
+  /** Absolute URLs declared with `Sitemap:` directives. */
+  sitemapUrls: string[];
+};
+/**
+ * Parse a `robots.txt`, keeping the rules Googlebot would follow: the
+ * `googlebot` group when one exists, the `*` group otherwise.
+ */
+export declare const parseRobots: (content: string) => ParsedRobots;
+/**
+ * Whether Googlebot may crawl `pathWithSearch` (path + query string) under the
+ * parsed rules. Follows Google's precedence: the longest matching rule wins,
+ * `Allow` wins ties.
+ */
+export declare const isPathAllowedByRobots: (pathWithSearch: string, robots: Pick<ParsedRobots, 'disallowedPaths' | 'allowedPaths'>) => boolean;
+//#endregion
+//# sourceMappingURL=robots.d.ts.map

package/dist/types/scan/robots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"robots.d.ts","names":[],"sources":["../../../src/scan/robots.ts"],"mappings":";;YACY;;EAEV;;EAEA;;EAEA;;;;;;qBAaW,cAAW,oBAAsB;;;;;;qBAsEjC,wBAAqB,wBACV,QACd,KAAK"}

package/dist/types/scan/runScanChecks.d.ts

@@ -0,0 +1,43 @@
+import { TechnologyDetectionInput } from "./detection/detectTechnologies.js";
+import { BundleChunkInput, ScanResult } from "./types.js";
+import { ScanFetchOptions } from "./fetchText.js";
+import { EmitScanEvent } from "./checks.js";
+//#region src/scan/runScanChecks.d.ts
+/** Page material gathered by the caller (fetch, puppeteer, browser…). */
+export type ScanPageInput = {
+  /** Absolute URL of the scanned page. */
+  targetUrl: string;
+  /** HTML of the page, rendered when possible. */
+  html: string;
+  /** Fetched JavaScript chunks. */
+  chunks: BundleChunkInput[];
+  /** Total transferred bytes measured for the page. */
+  totalPageSize: number;
+  /** Network request URLs observed while loading the page. */
+  requestUrls?: string[];
+  /** Live-page signals (globals, storage keys) for technology detection. */
+  runtimeSignals?: Pick<TechnologyDetectionInput, 'globals' | 'storageKeys' | 'globalVersions'>;
+};
+/** Page-level information available before the network-bound checks. */
+export type ScanPageInfo = Pick<ScanResult, 'metadata' | 'routing' | 'technologies' | 'locales'>;
+/** Options of {@link runScanChecks}. */
+export type RunScanChecksOptions = ScanFetchOptions & {
+  /** Called before each step, e.g. to stream a progress bar. */
+  onProgress?: (progress: number, message: string) => void;
+  /** Called once the page itself is analyzed (metadata, routing, stack). */
+  onPageInfo?: (pageInfo: ScanPageInfo) => void;
+};
+/** Output of {@link runScanChecks}. */
+export type ScanChecksResult = Pick<ScanResult, 'metadata' | 'routing' | 'technologies' | 'locales' | 'bundle'>;
+/**
+ * Run every i18n/SEO check on an already loaded page. Single implementation
+ * shared by the `intlayer scan` CLI and the hosted audit (`/api/scan`), which
+ * only differ in how they load the page.
+ *
+ * @param input - The loaded page (HTML, chunks, size, runtime signals).
+ * @param emit - Receives every check result as soon as it is produced.
+ * @param options - Network options and progress callbacks.
+ */
+export declare const runScanChecks: ({ targetUrl, html, chunks, totalPageSize, requestUrls, runtimeSignals }: ScanPageInput, emit: EmitScanEvent, { onProgress, onPageInfo, ...fetchOptions }: RunScanChecksOptions) => Promise<ScanChecksResult>;
+//#endregion
+//# sourceMappingURL=runScanChecks.d.ts.map

package/dist/types/scan/runScanChecks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runScanChecks.d.ts","names":[],"sources":["../../../src/scan/runScanChecks.ts"],"mappings":";;;;;;YAuCY;;EAEV;;EAEA;;EAEA,QAAQ;;EAER;;EAEA;;EAEA,iBAAiB,KACf;;;YAMQ,eAAe,KACzB;;YAKU,uBAAuB;;EAEjC,cAAc,kBAAkB;;EAEhC,cAAc,UAAU;;;YAId,mBAAmB,KAC7B;;;;;;;;;;qBAuBW,kBAAa,WAAA,MAAA,QAAA,eAAA,aAAA,kBAQrB,eAAa,MACV,iBAAa,YAAA,eAAA,gBAC0B,yBAC5C,QAAQ"}

package/dist/types/scan/scanWebsite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scanWebsite.d.ts","names":[],"sources":["../../../src/scan/scanWebsite.ts"],"mappings":";;;;;;;;;;;;;qBAmNa,cAAW,mBACL,UACR,gBACR,QAAQ"}
+{"version":3,"file":"scanWebsite.d.ts","names":[],"sources":["../../../src/scan/scanWebsite.ts"],"mappings":";;;;;;;;;;;;;qBAmOa,cAAW,mBACL,UACR,gBACR,QAAQ"}

package/dist/types/scan/sitemap.d.ts

@@ -0,0 +1,49 @@
+import { ScanFetchOptions } from "./fetchText.js";
+//#region src/scan/sitemap.d.ts
+/** A `<url>` entry of a sitemap with its hreflang alternates. */
+export type SitemapEntry = {
+  loc: string;
+  alternates: {
+    hreflang: string;
+    href: string;
+  }[];
+};
+/** Result of {@link parseSitemap}. */
+export type ParsedSitemap = {
+  /** `<url>` entries (empty for a sitemap index). */
+  entries: SitemapEntry[];
+  /** Child sitemap URLs, when the document is a `<sitemapindex>`. */
+  childSitemapUrls: string[];
+};
+/** Result of {@link collectSitemapEntries}. */
+export type CollectedSitemaps = {
+  /** Sitemap URLs that answered with a valid document. */
+  fetchedSitemapUrls: string[];
+  entries: SitemapEntry[];
+  /** Whether the entry limit was reached before reading every sitemap. */
+  isTruncated: boolean;
+};
+/**
+ * Parse a sitemap or sitemap index (regex based, no XML dependency). Handles
+ * `<xhtml:link rel="alternate" hreflang>` alternates in any namespace prefix.
+ */
+export declare const parseSitemap: (xml: string) => ParsedSitemap;
+/**
+ * Fetch the given sitemaps, following sitemap indexes one level deep, and
+ * gather their `<url>` entries.
+ *
+ * @param sitemapUrls - Sitemaps to read (from `robots.txt`, else defaults).
+ * @param fetchOptions - Network options, including the SSRF guard.
+ */
+export declare const collectSitemapEntries: (sitemapUrls: string[], fetchOptions: ScanFetchOptions) => Promise<CollectedSitemaps>;
+/** Default sitemap locations tried when `robots.txt` declares none. */
+export declare const getDefaultSitemapUrls: (origin: string) => string[];
+/**
+ * List the page URLs of a site from its sitemaps (primary `<loc>` and every
+ * hreflang alternate), used to seed a multi-page audit.
+ *
+ * @returns De-duplicated URLs, or `[targetUrl]` when no sitemap is found.
+ */
+export declare const discoverSitemapUrls: (targetUrl: string, fetchOptions: ScanFetchOptions) => Promise<string[]>;
+//#endregion
+//# sourceMappingURL=sitemap.d.ts.map

package/dist/types/scan/sitemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sitemap.d.ts","names":[],"sources":["../../../src/scan/sitemap.ts"],"mappings":";;;YAIY;EACV;EACA;IAAc;IAAkB;;;;YAItB;;EAEV,SAAS;;EAET;;;YAIU;;EAEV;EACA,SAAS;;EAET;;;;;;qBAiCW,eAAY,gBAAkB;;;;;;;;qBA6B9B,wBAAqB,uBACX,cACP,qBACb,QAAQ;;qBAoCE,wBAAqB;;;;;;;qBAWrB,sBAAmB,mBACb,cACH,qBACb"}

package/dist/types/scan/types.d.ts

@@ -1,4 +1,6 @@
 import { Score } from "./calculateScore.js";
+import { RoutingDetection } from "./detection/detectRoutingStrategy.js";
+import { DetectedTechnology } from "./detection/detectTechnologies.js";
 //#region src/scan/types.d.ts
 /** Status of an individual scan check. */
 export type ScanCheckStatus = 'success' | 'warning' | 'error';
@@ -66,6 +68,13 @@ export type ScanOptions = {
   /** Override the User-Agent used for every request. */
   userAgent?: string;
 };
+/** Title, description and preview image of the scanned page. */
+export type PageMetadata = {
+  title: string;
+  description: string;
+  /** Absolute `og:image` URL, `''` when absent. */
+  image: string;
+};
 /** Result of scanning a single page. */
 export type ScanResult = {
   url: string;
@@ -85,6 +94,12 @@ export type ScanResult = {
   locales: string[];
   /** Locale-weight breakdown of the bundles, when computable. */
   bundle?: BundleContentAnalysis;
+  /** How the site encodes the locale in its URLs. */
+  routing: RoutingDetection;
+  /** Frameworks, i18n libraries, TMS and translation proxies detected. */
+  technologies: DetectedTechnology[];
+  /** Title, description and preview image of the page. */
+  metadata: PageMetadata;
 };
 //#endregion
 //# sourceMappingURL=types.d.ts.map

package/dist/types/scan/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/scan/types.ts"],"mappings":";;;YAGY;;YAGA;EACV;EACA;EACA;;;;;;YAOU;EACV;EACA,QAAQ;EACR,UAAU;;;YAIA;;YAGA;EACV;;EAEA;EACA;;;YAIU;EACV;EACA;EACA;EACA;EACA;EACA;;EAEA;;;YAIU;EACV;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;EACA,kBAAkB;EAClB,kBAAkB;;;YAIR;;;;;;EAMV;;EAEA;;EAEA;;;YAIU;EACV;;EAEA,MAAM;;EAEN;;EAEA;;EAEA;;EAEA,UAAU;;EAEV,QAAQ;;EAER;;EAEA,SAAS"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/scan/types.ts"],"mappings":";;;;;YAKY;;YAGA;EACV;EACA;EACA;;;;;;YAOU;EACV;EACA,QAAQ;EACR,UAAU;;;YAIA;;YAGA;EACV;;EAEA;EACA;;;YAIU;EACV;EACA;EACA;EACA;EACA;EACA;;EAEA;;;YAIU;EACV;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;EACA,kBAAkB;EAClB,kBAAkB;;;YAIR;;;;;;EAMV;;EAEA;;EAEA;;;YAIU;EACV;EACA;;EAEA;;;YAIU;EACV;;EAEA,MAAM;;EAEN;;EAEA;;EAEA;;EAEA,UAAU;;EAEV,QAAQ;;EAER;;EAEA,SAAS;;EAET,SAAS;;EAET,cAAc;;EAEd,UAAU"}

package/dist/types/utils/chunkJSON.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunkJSON.d.ts","names":[],"sources":["../../../src/utils/chunkJSON.ts"],"mappings":";;;;;;;;KAUK;KACA,YAAY,gBAAgB,aAAa;YAElC;GACT,YAAY;;KAGV,YAAY;KAEZ,OAAO;KAEP;EAAa;EAAW,MAAM;EAAM,OAAO;;KAC3C;EACH;EACA,MAAM;EACN;EACA;EACA;;KAEG,QAAQ,WAAW;KAEnB;YAEO;EACV;EACA;EACA;EACA,UAAU;EACV;EACA,SAAS;;;;;qBAiME,YAAS,OACb,aAAa,WAAS,qBAE5B;;;;;;;;;;;qBAsHU,6BAA0B,OAC9B,cACN,aAAa;qBAiGH,eAAY,QAAY,gBAAc,aAAa"}
+{"version":3,"file":"chunkJSON.d.ts","names":[],"sources":["../../../src/utils/chunkJSON.ts"],"mappings":";;;;;;;;KAUK;KACA,YAAY,gBAAgB,aAAa;YAElC;GACT,YAAY;;KAGV,YAAY;KAEZ,OAAO;KAEP;EAAa;EAAW,MAAM;EAAM,OAAO;;KAC3C;EACH;EACA,MAAM;EACN;EACA;EACA;;KAEG,QAAQ,WAAW;KAEnB;YAEO;EACV;EACA;EACA;EACA,UAAU;EACV;EACA,SAAS;;;;;qBA+ME,YAAS,OACb,aAAa,WAAS,qBAE5B;;;;;;;;;;;qBAsHU,6BAA0B,OAC9B,cACN,aAAa;qBAiGH,eAAY,QAAY,gBAAc,aAAa"}

package/dist/types/utils/getProcessChainCommands.d.ts

@@ -0,0 +1,35 @@
+//#region src/utils/getProcessChainCommands.d.ts
+/** Process as listed by the OS: its parent and the command line it runs. */
+export type ProcessEntry = {
+  parentPid: number;
+  command: string;
+};
+/**
+ * Parses the output of `ps -A -o pid=,ppid=,command=`.
+ *
+ * @param output - One `<pid> <ppid> <command>` row per line.
+ * @returns The processes, keyed by PID.
+ */
+export declare const parseProcessTable: (output: string) => Map<number, ProcessEntry>;
+/**
+ * Command lines of this process and of the processes above it, closest first.
+ *
+ * This process is included because some runtimes restart the script inside
+ * the same process, leaving their watch flag only on their own command line
+ * (`deno run --watch`).
+ *
+ * Best effort: resolves to an empty list on Windows, or when the process list
+ * cannot be read (sandbox, missing `ps`, Deno without the permission), and
+ * never throws.
+ *
+ * @param maxDepth - How many processes to read at most, this one included.
+ *
+ * @example
+ * ```ts
+ * await getProcessChainCommands();
+ * // → ['node src/index.js', 'node …/nodemon src/index.js', 'npm run dev']
+ * ```
+ */
+export declare const getProcessChainCommands: (maxDepth?: number) => Promise<string[]>;
+//#endregion
+//# sourceMappingURL=getProcessChainCommands.d.ts.map

package/dist/types/utils/getProcessChainCommands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getProcessChainCommands.d.ts","names":[],"sources":["../../../src/utils/getProcessChainCommands.ts"],"mappings":";;YAKY;EACV;EACA;;;;;;;;qBAYW,oBAAiB,mBAE3B,YAAY;;;;;;;;;;;;;;;;;;;;qBA2GF,0BAAuB,sBAEjC"}

package/dist/types/utils/index.d.ts

@@ -20,6 +20,7 @@ import { RunOnceContext, runOnce } from "./runOnce.js";
 import { ParallelHandle, runParallel } from "./runParallel/index.js";
 import { sortAlphabetically } from "./sortAlphabetically.js";
 import { splitTextByLines } from "./splitTextByLine.js";
+import { StartContentWatcherOptions, startContentWatcher } from "./startContentWatcher.js";
 import { verifyIdenticObjectFormat } from "./verifyIdenticObjectFormat.js";
 import { withFileLock } from "./withFileLock.js";
-export { CLI_CONTENT_WATCHER_ENV_VAR, ContentDeclarationFileName, ContentWatcherOwner, ContentWatcherSource, Extension, Format, JSONObject, JsonChunk, ParallelHandle, Primitive, Queue, Recursive, RunOnceContext, acquireContentWatcherLock, assembleJSON, autoDecorateContent, buildComponentFilesList, chunkArray, chunkJSON, claimCliContentWatcher, excludeObjectFormat, formatLocale, formatPath, getChunk, getCliContentWatcherLabel, getContentExtension, getContentWatcherLockFilePath, getContentWatcherOwner, getExtensionFromFormat, getFormatFromExtension, getGlobalLimiter, getPathHash, getTaskLimiter, mergeChunks, pLimit, parallelize, parallelizeGlobal, parseContentDeclarationFileName, reconstructFromSingleChunk, reduceObjectFormat, reportRedundantContentWatcher, resolveObjectPromises, resolveRelativePath, runOnce, runParallel, sortAlphabetically, splitTextByLines, verifyIdenticObjectFormat, withFileLock };
+export { CLI_CONTENT_WATCHER_ENV_VAR, ContentDeclarationFileName, ContentWatcherOwner, ContentWatcherSource, Extension, Format, JSONObject, JsonChunk, ParallelHandle, Primitive, Queue, Recursive, RunOnceContext, StartContentWatcherOptions, acquireContentWatcherLock, assembleJSON, autoDecorateContent, buildComponentFilesList, chunkArray, chunkJSON, claimCliContentWatcher, excludeObjectFormat, formatLocale, formatPath, getChunk, getCliContentWatcherLabel, getContentExtension, getContentWatcherLockFilePath, getContentWatcherOwner, getExtensionFromFormat, getFormatFromExtension, getGlobalLimiter, getPathHash, getTaskLimiter, mergeChunks, pLimit, parallelize, parallelizeGlobal, parseContentDeclarationFileName, reconstructFromSingleChunk, reduceObjectFormat, reportRedundantContentWatcher, resolveObjectPromises, resolveRelativePath, runOnce, runParallel, sortAlphabetically, splitTextByLines, startContentWatcher, verifyIdenticObjectFormat, withFileLock };

package/dist/types/utils/runParallel/pidTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pidTree.d.ts","names":[],"sources":["../../../../src/utils/runParallel/pidTree.ts"],"mappings":";UAgBU;EACR;EACA;;KAGG;EAAgB;EAAa;;KAC7B,WAAW,UAAU,2BAA2B;EACnD;IAEE;KAIC,aAAa,UAAU,4BAC1B,KAAK,cACL,OAAO,WAAW;;;;;;;;qBA8LP,OAAQ,UAAU,yBAAuB,sBAChC,UACV,IAAI,aAAa,IAAE,WAClB,aAAa,OACvB,QAAQ,WAAW"}
+{"version":3,"file":"pidTree.d.ts","names":[],"sources":["../../../../src/utils/runParallel/pidTree.ts"],"mappings":";UAgBU;EACR;EACA;;KAGG;EAAgB;EAAa;;KAC7B,WAAW,UAAU,2BAA2B;EACnD;IAEE;KAIC,aAAa,UAAU,4BAC1B,KAAK,cACL,OAAO,WAAW;;;;;;;;qBA+MP,OAAQ,UAAU,yBAAuB,sBAChC,UACV,IAAI,aAAa,IAAE,WAClB,aAAa,OACvB,QAAQ,WAAW"}

package/dist/types/utils/startContentWatcher.d.ts

@@ -0,0 +1,40 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+//#region src/utils/startContentWatcher.d.ts
+export type StartContentWatcherOptions = {
+  /**
+   * How the integration names itself in the lock and in messages, e.g.
+   * `vite-intlayer`.
+   */
+  label: string;
+  /**
+   * Whether this process must never own the watcher, re-checked on every
+   * attempt (e.g. a helper process that outlives the dev server).
+   */
+  getShouldSkip?: () => boolean;
+};
+/**
+ * Starts the content declaration watcher from an integration (bundler plugin or
+ * server middleware), making sure only one watcher rebuilds a project's
+ * dictionaries.
+ *
+ * - Idempotent within a process, across module copies and hot reloads.
+ * - Stands down, with an explanation, when `intlayer watch` already covers the
+ *   project, whether it spawned this process (`--with`) or runs elsewhere.
+ * - Otherwise the first process to take the project lock watches; the others
+ *   retry in the background to take over once it stops.
+ *
+ * Not awaitable on purpose: a dev server must not wait on the watcher to serve.
+ *
+ * @param configuration - The resolved Intlayer configuration.
+ * @param options - How the integration identifies itself.
+ *
+ * @example
+ * ```ts
+ * configureServer() {
+ *   startContentWatcher(configuration, { label: 'vite-intlayer' });
+ * }
+ * ```
+ */
+export declare const startContentWatcher: (configuration: IntlayerConfig, options: StartContentWatcherOptions) => void;
+//#endregion
+//# sourceMappingURL=startContentWatcher.d.ts.map

package/dist/types/utils/startContentWatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startContentWatcher.d.ts","names":[],"sources":["../../../src/utils/startContentWatcher.ts"],"mappings":";;YAgBY;;;;;EAKV;;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;;;;qBA6GW,sBAAmB,eACf,gBAAc,SACpB"}

package/dist/types/watcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watcher.d.ts","names":[],"sources":["../../src/watcher.ts"],"mappings":";;;KA2DK;EACH,gBAAgB;EAChB,gBAAgB;EAChB;EACA;;qBAsBW,QAAK,UAAoB,iBAAY;EAkDZ,mBAAM;;qBA2Q/B,wBAAqB,UAAoB,iBAAY"}
+{"version":3,"file":"watcher.d.ts","names":[],"sources":["../../src/watcher.ts"],"mappings":";;;KA0DK;EACH,gBAAgB;EAChB,gBAAgB;EAChB;EACA;;qBAsBW,QAAK,UAAoB,iBAAY;EAkDZ,mBAAM;;qBAgR/B,wBAAqB,UAAoB,iBAAY"}

package/dist/types/writeContentDeclaration/writeMarkdownFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeMarkdownFile.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/writeMarkdownFile.ts"],"mappings":";;;qBA4Da,oBAAiB,0BACJ,YACZ,YAAU,eACP,mBACd"}
+{"version":3,"file":"writeMarkdownFile.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/writeMarkdownFile.ts"],"mappings":";;;qBA+Da,oBAAiB,0BACJ,YACZ,YAAU,eACP,mBACd"}