@intlayer/chokidar 8.12.4 → 9.0.0-canary.0

package/dist/esm/scan/scanWebsite.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanWebsite.mjs","names":[],"sources":["../../../src/scan/scanWebsite.ts"],"sourcesContent":["import { GREY, GREY_LIGHT } from '@intlayer/config/colors';\nimport { colorize, logger } from '@intlayer/config/logger';\nimport { mutateScore, type Score, toScorePercent } from './calculateScore';\nimport {\n  checkBundleContent,\n  checkCanonical,\n  checkHtmlAttributes,\n  checkLinguisticStructure,\n  checkRobots,\n  checkSitemap,\n  checkUrlStructure,\n} from './checks';\nimport { byteLength, extractAnchors, extractScriptUrls } from './parseHtml';\nimport type {\n  BundleChunkInput,\n  ScanEvent,\n  ScanOptions,\n  ScanResult,\n} from './types';\n\nconst DEFAULT_USER_AGENT =\n  'Mozilla/5.0 (compatible; IntlayerScanBot/1.0; +https://intlayer.org)';\nconst DEFAULT_TIMEOUT_MS = 30_000;\n\n/**\n * Log a recommendation to install `puppeteer` for a deeper scan. Mirrors the\n * style used by other optional-dependency hints across the CLI.\n */\nconst logDeepScanRecommendation = (): void => {\n  logger([\n    colorize('Recommended: Install', GREY),\n    colorize('puppeteer', GREY_LIGHT),\n    colorize(\n      'package to enable a deeper scan (renders client-side content & lazy-loaded chunks). See documentation:',\n      GREY\n    ),\n    colorize('https://intlayer.org/doc/concept/cli#scan', GREY_LIGHT),\n  ]);\n};\n\n/** Outcome of a render-based deep scan. */\ntype DeepScanResult = {\n  html: string;\n  totalPageSize: number;\n  chunks: BundleChunkInput[];\n};\n\n/**\n * Render the page with a locally installed `puppeteer` to capture\n * client-rendered content, the accurate transfer size, and lazy-loaded chunks.\n *\n * `puppeteer` is imported dynamically through a non-literal specifier so it is\n * never bundled and stays an optional dependency: when it is absent the import\n * rejects and the caller falls back to the basic scan.\n *\n * @returns The deep-scan result, or `null` when `puppeteer` is unavailable.\n */\nconst runDeepScan = async (\n  targetUrl: string,\n  userAgent: string,\n  timeoutMs: number\n): Promise<DeepScanResult | null> => {\n  const moduleName = 'puppeteer';\n  // Optional dependency resolved at runtime — typed as `any` because it is not\n  // a declared dependency of this package.\n  let puppeteer: any;\n  try {\n    const mod: any = await import(moduleName);\n    puppeteer = mod.default ?? mod;\n  } catch {\n    return null;\n  }\n\n  let browser: any;\n  try {\n    browser = await puppeteer.launch({\n      headless: true,\n      executablePath: process.env.PUPPETEER_EXECUTABLE_PATH,\n      args: [\n        '--no-sandbox',\n        '--disable-setuid-sandbox',\n        '--disable-dev-shm-usage',\n        '--disable-gpu',\n      ],\n    });\n\n    const page = await browser.newPage();\n    await page.setUserAgent(userAgent);\n    await page.setExtraHTTPHeaders({ 'Accept-Language': 'en-US,en;q=0.9' });\n\n    const origin = new URL(targetUrl).origin;\n    const jsResponseMap = new Map<string, string>();\n    let totalPageSize = 0;\n    const pendingResponses: Promise<void>[] = [];\n\n    page.on('response', (response: any) => {\n      pendingResponses.push(\n        (async () => {\n          try {\n            if (response.status() !== 200) return;\n            const buffer = await response.buffer();\n            totalPageSize += buffer.length;\n\n            const responseUrl: string = response.url();\n            const contentType: string =\n              response.headers()['content-type'] ?? '';\n            const isJavaScript =\n              contentType.includes('javascript') ||\n              /\\.(js|mjs|cjs)(\\?|$)/.test(responseUrl);\n            if (isJavaScript && responseUrl.startsWith(origin)) {\n              jsResponseMap.set(responseUrl, buffer.toString('utf-8'));\n            }\n          } catch {\n            /* response already consumed or aborted */\n          }\n        })()\n      );\n    });\n\n    await page.goto(targetUrl, {\n      waitUntil: 'domcontentloaded',\n      timeout: timeoutMs,\n    });\n    await page\n      .waitForNetworkIdle({ idleTime: 1000, timeout: 10_000 })\n      .catch(() => {\n        /* ok if it never fully idles */\n      });\n    await Promise.allSettled(pendingResponses);\n\n    const html: string = await page.content();\n    const mainBundleUrls = new Set(extractScriptUrls(html, targetUrl));\n    const chunks: BundleChunkInput[] = Array.from(jsResponseMap.entries()).map(\n      ([url, content]) => ({\n        url,\n        isMainBundle: mainBundleUrls.has(url),\n        content,\n      })\n    );\n\n    return { html, totalPageSize, chunks };\n  } finally {\n    if (browser) await browser.close();\n  }\n};\n\n/** Fetch the raw HTML document, measuring its byte size. */\nconst fetchHtml = async (\n  url: string,\n  userAgent: string,\n  timeoutMs: number\n): Promise<{ html: string; finalUrl: string }> => {\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), timeoutMs);\n  try {\n    const response = await fetch(url, {\n      headers: { 'User-Agent': userAgent, 'Accept-Language': 'en-US,en;q=0.9' },\n      signal: controller.signal,\n    });\n    const html = await response.text();\n    return { html, finalUrl: response.url || url };\n  } finally {\n    clearTimeout(timer);\n  }\n};\n\n/**\n * Fetch every eagerly-loaded script. Same-origin scripts keep their content so\n * their locale weight can be analyzed; third-party scripts only contribute to\n * the measured page size (their locale-like keys cause false positives).\n */\nconst fetchScripts = async (\n  scriptUrls: string[],\n  origin: string,\n  userAgent: string\n): Promise<{ chunks: BundleChunkInput[]; scriptBytes: number }> => {\n  const chunks: BundleChunkInput[] = [];\n  let scriptBytes = 0;\n\n  await Promise.all(\n    scriptUrls.map(async (scriptUrl) => {\n      try {\n        const response = await fetch(scriptUrl, {\n          headers: { 'User-Agent': userAgent },\n        });\n        if (!response.ok) return;\n        const content = await response.text();\n        scriptBytes += byteLength(content);\n        if (scriptUrl.startsWith(origin)) {\n          chunks.push({ url: scriptUrl, isMainBundle: true, content });\n        }\n      } catch {\n        /* ignore unreachable scripts */\n      }\n    })\n  );\n\n  return { chunks, scriptBytes };\n};\n\n/**\n * Scan a single web page for i18n/SEO health and bundle weight.\n *\n * In `deep` mode (default) the page is rendered with a locally installed\n * `puppeteer`; when `puppeteer` is missing the scan transparently falls back to\n * a `basic` fetch-based pass and logs a recommendation to install it.\n *\n * @param targetUrl - The absolute URL to scan.\n * @param options - {@link ScanOptions} controlling depth, timeout and UA.\n * @returns The {@link ScanResult} including score, page size and per-check events.\n */\nexport const scanWebsite = async (\n  targetUrl: string,\n  options: ScanOptions = {}\n): Promise<ScanResult> => {\n  const {\n    deep = true,\n    timeoutMs = DEFAULT_TIMEOUT_MS,\n    userAgent = DEFAULT_USER_AGENT,\n  } = options;\n\n  const origin = new URL(targetUrl).origin;\n\n  let mode: ScanResult['mode'] = 'basic';\n  let html: string;\n  let totalPageSize: number;\n  let chunks: BundleChunkInput[];\n\n  const deepResult = deep\n    ? await runDeepScan(targetUrl, userAgent, timeoutMs)\n    : null;\n\n  if (deepResult) {\n    mode = 'deep';\n    html = deepResult.html;\n    chunks = deepResult.chunks;\n    totalPageSize = deepResult.totalPageSize;\n  } else {\n    if (deep) logDeepScanRecommendation();\n    const { html: fetchedHtml, finalUrl } = await fetchHtml(\n      targetUrl,\n      userAgent,\n      timeoutMs\n    );\n    html = fetchedHtml;\n    const scriptUrls = extractScriptUrls(fetchedHtml, finalUrl);\n    const { chunks: fetchedChunks, scriptBytes } = await fetchScripts(\n      scriptUrls,\n      origin,\n      userAgent\n    );\n    chunks = fetchedChunks;\n    totalPageSize = byteLength(fetchedHtml) + scriptBytes;\n  }\n\n  const htmlSize = byteLength(html);\n\n  const events: ScanEvent[] = [];\n  const localesSet = new Set<string>();\n\n  const { langTag } = checkHtmlAttributes(html, targetUrl, events);\n  checkCanonical(html, targetUrl, events);\n  checkLinguisticStructure(html, targetUrl, localesSet, events);\n  checkUrlStructure(extractAnchors(html), origin, targetUrl, events);\n  const bundle = checkBundleContent(\n    chunks,\n    html,\n    langTag,\n    targetUrl,\n    totalPageSize,\n    events\n  );\n  await checkRobots(origin, localesSet, userAgent, events);\n  await checkSitemap(origin, localesSet, userAgent, events);\n\n  const rawScore = events.reduce<Score>(\n    (score, event) => mutateScore(score, event),\n    { score: 0, totalScore: 0 }\n  );\n\n  return {\n    url: targetUrl,\n    mode,\n    totalPageSize,\n    htmlSize,\n    score: toScorePercent(rawScore),\n    rawScore,\n    events,\n    locales: Array.from(localesSet),\n    bundle,\n  };\n};\n"],"mappings":";;;;;;;AAoBA,MAAM,qBACJ;AACF,MAAM,qBAAqB;;;;;AAM3B,MAAM,kCAAwC;AAC5C,QAAO;EACL,SAAS,wBAAwB,KAAK;EACtC,SAAS,aAAa,WAAW;EACjC,SACE,0GACA,KACD;EACD,SAAS,6CAA6C,WAAW;EAClE,CAAC;;;;;;;;;;;;AAoBJ,MAAM,cAAc,OAClB,WACA,WACA,cACmC;CACnC,MAAM,aAAa;CAGnB,IAAI;AACJ,KAAI;EACF,MAAM,MAAW,MAAM,OAAO;AAC9B,cAAY,IAAI,WAAW;SACrB;AACN,SAAO;;CAGT,IAAI;AACJ,KAAI;AACF,YAAU,MAAM,UAAU,OAAO;GAC/B,UAAU;GACV,gBAAgB,QAAQ,IAAI;GAC5B,MAAM;IACJ;IACA;IACA;IACA;IACD;GACF,CAAC;EAEF,MAAM,OAAO,MAAM,QAAQ,SAAS;AACpC,QAAM,KAAK,aAAa,UAAU;AAClC,QAAM,KAAK,oBAAoB,EAAE,mBAAmB,kBAAkB,CAAC;EAEvE,MAAM,SAAS,IAAI,IAAI,UAAU,CAAC;EAClC,MAAM,gCAAgB,IAAI,KAAqB;EAC/C,IAAI,gBAAgB;EACpB,MAAM,mBAAoC,EAAE;AAE5C,OAAK,GAAG,aAAa,aAAkB;AACrC,oBAAiB,MACd,YAAY;AACX,QAAI;AACF,SAAI,SAAS,QAAQ,KAAK,IAAK;KAC/B,MAAM,SAAS,MAAM,SAAS,QAAQ;AACtC,sBAAiB,OAAO;KAExB,MAAM,cAAsB,SAAS,KAAK;AAM1C,WAJE,SAAS,SAAS,CAAC,mBAAmB,IAE1B,SAAS,aAAa,IAClC,uBAAuB,KAAK,YAAY,KACtB,YAAY,WAAW,OAAO,CAChD,eAAc,IAAI,aAAa,OAAO,SAAS,QAAQ,CAAC;YAEpD;OAGN,CACL;IACD;AAEF,QAAM,KAAK,KAAK,WAAW;GACzB,WAAW;GACX,SAAS;GACV,CAAC;AACF,QAAM,KACH,mBAAmB;GAAE,UAAU;GAAM,SAAS;GAAQ,CAAC,CACvD,YAAY,GAEX;AACJ,QAAM,QAAQ,WAAW,iBAAiB;EAE1C,MAAM,OAAe,MAAM,KAAK,SAAS;EACzC,MAAM,iBAAiB,IAAI,IAAI,kBAAkB,MAAM,UAAU,CAAC;EAClE,MAAM,SAA6B,MAAM,KAAK,cAAc,SAAS,CAAC,CAAC,KACpE,CAAC,KAAK,cAAc;GACnB;GACA,cAAc,eAAe,IAAI,IAAI;GACrC;GACD,EACF;AAED,SAAO;GAAE;GAAM;GAAe;GAAQ;WAC9B;AACR,MAAI,QAAS,OAAM,QAAQ,OAAO;;;;AAKtC,MAAM,YAAY,OAChB,KACA,WACA,cACgD;CAChD,MAAM,aAAa,IAAI,iBAAiB;CACxC,MAAM,QAAQ,iBAAiB,WAAW,OAAO,EAAE,UAAU;AAC7D,KAAI;EACF,MAAM,WAAW,MAAM,MAAM,KAAK;GAChC,SAAS;IAAE,cAAc;IAAW,mBAAmB;IAAkB;GACzE,QAAQ,WAAW;GACpB,CAAC;AAEF,SAAO;GAAE,YADU,SAAS,MAAM;GACnB,UAAU,SAAS,OAAO;GAAK;WACtC;AACR,eAAa,MAAM;;;;;;;;AASvB,MAAM,eAAe,OACnB,YACA,QACA,cACiE;CACjE,MAAM,SAA6B,EAAE;CACrC,IAAI,cAAc;AAElB,OAAM,QAAQ,IACZ,WAAW,IAAI,OAAO,cAAc;AAClC,MAAI;GACF,MAAM,WAAW,MAAM,MAAM,WAAW,EACtC,SAAS,EAAE,cAAc,WAAW,EACrC,CAAC;AACF,OAAI,CAAC,SAAS,GAAI;GAClB,MAAM,UAAU,MAAM,SAAS,MAAM;AACrC,kBAAe,WAAW,QAAQ;AAClC,OAAI,UAAU,WAAW,OAAO,CAC9B,QAAO,KAAK;IAAE,KAAK;IAAW,cAAc;IAAM;IAAS,CAAC;UAExD;GAGR,CACH;AAED,QAAO;EAAE;EAAQ;EAAa;;;;;;;;;;;;;AAchC,MAAa,cAAc,OACzB,WACA,UAAuB,EAAE,KACD;CACxB,MAAM,EACJ,OAAO,MACP,YAAY,oBACZ,YAAY,uBACV;CAEJ,MAAM,SAAS,IAAI,IAAI,UAAU,CAAC;CAElC,IAAI,OAA2B;CAC/B,IAAI;CACJ,IAAI;CACJ,IAAI;CAEJ,MAAM,aAAa,OACf,MAAM,YAAY,WAAW,WAAW,UAAU,GAClD;AAEJ,KAAI,YAAY;AACd,SAAO;AACP,SAAO,WAAW;AAClB,WAAS,WAAW;AACpB,kBAAgB,WAAW;QACtB;AACL,MAAI,KAAM,4BAA2B;EACrC,MAAM,EAAE,MAAM,aAAa,aAAa,MAAM,UAC5C,WACA,WACA,UACD;AACD,SAAO;EAEP,MAAM,EAAE,QAAQ,eAAe,gBAAgB,MAAM,aADlC,kBAAkB,aAAa,SAEtC,EACV,QACA,UACD;AACD,WAAS;AACT,kBAAgB,WAAW,YAAY,GAAG;;CAG5C,MAAM,WAAW,WAAW,KAAK;CAEjC,MAAM,SAAsB,EAAE;CAC9B,MAAM,6BAAa,IAAI,KAAa;CAEpC,MAAM,EAAE,YAAY,oBAAoB,MAAM,WAAW,OAAO;AAChE,gBAAe,MAAM,WAAW,OAAO;AACvC,0BAAyB,MAAM,WAAW,YAAY,OAAO;AAC7D,mBAAkB,eAAe,KAAK,EAAE,QAAQ,WAAW,OAAO;CAClE,MAAM,SAAS,mBACb,QACA,MACA,SACA,WACA,eACA,OACD;AACD,OAAM,YAAY,QAAQ,YAAY,WAAW,OAAO;AACxD,OAAM,aAAa,QAAQ,YAAY,WAAW,OAAO;CAEzD,MAAM,WAAW,OAAO,QACrB,OAAO,UAAU,YAAY,OAAO,MAAM,EAC3C;EAAE,OAAO;EAAG,YAAY;EAAG,CAC5B;AAED,QAAO;EACL,KAAK;EACL;EACA;EACA;EACA,OAAO,eAAe,SAAS;EAC/B;EACA;EACA,SAAS,MAAM,KAAK,WAAW;EAC/B;EACD"}

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

@@ -1 +1 @@
-{"version":3,"file":"buildIntlayerDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/buildIntlayerDictionary.ts"],"mappings":";;;;;;;;KAYY,wBAAA,GAA2B,OAAA;EACrC,OAAA,SAAgB,aAAA;EAChB,uBAAA;EACA,GAAA;AAAA;;;;cAYW,eAAA,GACX,wBAAA,EAA0B,UAAA,IAC1B,aAAA,EAAe,cAAA,EACf,OAAA,GAAU,wBAAA,KAAwB,OAAA;wBAAA,wBAAA"}
+{"version":3,"file":"buildIntlayerDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/buildIntlayerDictionary.ts"],"mappings":";;;;;;;;KAmBY,wBAAA,GAA2B,OAAA;EACrC,OAAA,SAAgB,aAAA;EAChB,uBAAA;EACA,GAAA;AAAA;;;;cAYW,eAAA,GACX,wBAAA,EAA0B,UAAA,IAC1B,aAAA,EAAe,cAAA,EACf,OAAA,GAAU,wBAAA,KAAwB,OAAA;wBAAA,wBAAA"}

package/dist/types/buildIntlayerDictionary/writeDynamicDictionary.d.ts

@@ -1,6 +1,6 @@
-import { MergedDictionaryOutput } from "./writeMergedDictionary.js";
+import { PlainMergedDictionaryOutput } from "./writeMergedDictionary.js";
 import { IntlayerConfig } from "@intlayer/types/config";
-import { Dictionary } from "@intlayer/types/dictionary";
+import { Dictionary, DictionaryQualifierType, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 import { Locale } from "@intlayer/types/allLocales";
 
 //#region src/buildIntlayerDictionary/writeDynamicDictionary.d.ts
@@ -14,6 +14,17 @@ type LocalizedDictionaryOutput = Record<string, LocalizedDictionaryResult>;
  * Generates the content of a dictionary entry point file.
  */
 declare const generateDictionaryEntryPoint: (key: string, locales: string[], format?: "cjs" | "esm") => string;
+/**
+ * Generates the entry point of a qualified dictionary (collection / variant /
+ * meta record, possibly combined). Under each locale the loader map nests one
+ * level per declared dimension (canonical order) and carries a marker listing
+ * those dimensions so the runtime can walk the tree.
+ *
+ * One static `import()` is emitted per leaf `(locale, …segments)` chunk, which
+ * keeps the output compatible with bundlers that reject template-literal
+ * dynamic imports (Turbopack).
+ */
+declare const generateQualifiedDictionaryEntryPoint: (key: string, qualifierTypes: DictionaryQualifierType[], entriesSegments: string[][], locales: string[], format?: "cjs" | "esm") => string;
 /**
  * Write the localized dictionaries to the dictionariesDir
  * @param mergedDictionaries - The merged dictionaries
@@ -30,7 +41,23 @@ declare const generateDictionaryEntryPoint: (key: string, locales: string[], for
  * // .intlayer/dynamic_dictionary/dictionaries/fr_home.json
  * ```
  */
-declare const writeDynamicDictionary: (mergedDictionaries: MergedDictionaryOutput, configuration: IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<LocalizedDictionaryOutput>;
+declare const writeDynamicDictionary: (mergedDictionaries: PlainMergedDictionaryOutput, configuration: IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<LocalizedDictionaryOutput>;
+type QualifiedMergedDictionaryResult = {
+  dictionaryPath: string;
+  dictionary: QualifiedDictionaryGroup;
+};
+type QualifiedMergedDictionaryOutput = Record<string, QualifiedMergedDictionaryResult>;
+/**
+ * Writes the dynamic chunks and entry points of qualified dictionaries
+ * (collections, variants, meta records — possibly combined) in
+ * `importMode: 'dynamic'`.
+ *
+ * Each entry is reduced to one per-locale chunk written to a path nested by
+ * dimension — `json/{key}/{seg1}/{seg2}/{locale}.json` — and a single
+ * `{key}.{ext}` entry point exposes the matching nested loader tree, so the
+ * entry point is discovered and aggregated exactly like a plain dynamic one.
+ */
+declare const writeDynamicQualifiedDictionaries: (qualifiedDictionaries: QualifiedMergedDictionaryOutput, configuration: IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<void>;
 //#endregion
-export { DictionaryResult, LocalizedDictionaryOutput, LocalizedDictionaryResult, generateDictionaryEntryPoint, writeDynamicDictionary };
+export { DictionaryResult, LocalizedDictionaryOutput, LocalizedDictionaryResult, QualifiedMergedDictionaryOutput, QualifiedMergedDictionaryResult, generateDictionaryEntryPoint, generateQualifiedDictionaryEntryPoint, writeDynamicDictionary, writeDynamicQualifiedDictionaries };
 //# sourceMappingURL=writeDynamicDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeDynamicDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeDynamicDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"mappings":";;;;;;KAcY,gBAAA;EACV,cAAA;EACA,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,yBAAA,GAA4B,OAAA,CACtC,MAAA,CAAO,MAAA,EAAQ,gBAAA;AAAA,KAGL,yBAAA,GAA4B,MAAA,SAEtC,yBAAA;;;;cAQW,4BAAA,GACX,GAAA,UACA,OAAA,YACA,MAAA;;AAjBF;;;;;;;;;;;;;;;cAwDa,sBAAA,GACX,kBAAA,EAAoB,sBAAA,EACpB,aAAA,EAAe,cAAA,EACf,OAAA,yBACC,OAAA,CAAQ,yBAAA"}
+{"version":3,"file":"writeDynamicDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"mappings":";;;;;;KAuBY,gBAAA;EACV,cAAA;EACA,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,yBAAA,GAA4B,OAAA,CACtC,MAAA,CAAO,MAAA,EAAQ,gBAAA;AAAA,KAGL,yBAAA,GAA4B,MAAA,SAEtC,yBAAA;;;;cAQW,4BAAA,GACX,GAAA,UACA,OAAA,YACA,MAAA;;AAjBF;;;;;;;;;cAiHa,qCAAA,GACX,GAAA,UACA,cAAA,EAAgB,uBAAA,IAChB,eAAA,cACA,OAAA,YACA,MAAA;;;;;;AAlHF;;;;;AAUA;;;;;;cAgJa,sBAAA,GACX,kBAAA,EAAoB,2BAAA,EACpB,aAAA,EAAe,cAAA,EACf,OAAA,yBACC,OAAA,CAAQ,yBAAA;AAAA,KAyEC,+BAAA;EACV,cAAA;EACA,UAAA,EAAY,wBAAA;AAAA;AAAA,KAGF,+BAAA,GAAkC,MAAA,SAE5C,+BAAA;;;;;;;;;;AApFF;cAiGa,iCAAA,GACX,qBAAA,EAAuB,+BAAA,EACvB,aAAA,EAAe,cAAA,EACf,OAAA,yBACC,OAAA"}

package/dist/types/buildIntlayerDictionary/writeMergedDictionary.d.ts

@@ -1,13 +1,23 @@
 import { UnmergedDictionaryOutput } from "./writeUnmergedDictionary.js";
 import { IntlayerConfig } from "@intlayer/types/config";
-import { Dictionary } from "@intlayer/types/dictionary";
+import { Dictionary, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 
 //#region src/buildIntlayerDictionary/writeMergedDictionary.d.ts
 type MergedDictionaryResult = {
   dictionaryPath: string;
-  dictionary: Dictionary;
+  dictionary: Dictionary | QualifiedDictionaryGroup;
 };
 type MergedDictionaryOutput = Record<string, MergedDictionaryResult>;
+/**
+ * Merged output restricted to plain (unqualified) dictionaries — qualified
+ * groups (collections, variants, meta records) are static-only and filtered
+ * out before the dynamic/fetch build steps.
+ */
+type PlainMergedDictionaryResult = {
+  dictionaryPath: string;
+  dictionary: Dictionary;
+};
+type PlainMergedDictionaryOutput = Record<string, PlainMergedDictionaryResult>;
 /**
  * Write the merged dictionaries to the dictionariesDir
  * @param groupedDictionaries - The grouped dictionaries
@@ -26,5 +36,5 @@ type MergedDictionaryOutput = Record<string, MergedDictionaryResult>;
  */
 declare const writeMergedDictionaries: (groupedDictionaries: UnmergedDictionaryOutput, configuration: IntlayerConfig) => Promise<MergedDictionaryOutput>;
 //#endregion
-export { MergedDictionaryOutput, MergedDictionaryResult, writeMergedDictionaries };
+export { MergedDictionaryOutput, MergedDictionaryResult, PlainMergedDictionaryOutput, PlainMergedDictionaryResult, writeMergedDictionaries };
 //# sourceMappingURL=writeMergedDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeMergedDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeMergedDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeMergedDictionary.ts"],"mappings":";;;;;KAcY,sBAAA;EACV,cAAA;EACA,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,sBAAA,GAAyB,MAAA,SAAe,sBAAA;;;;;;;AAApD;;;;;AAkBA;;;;;cAAa,uBAAA,GACX,mBAAA,EAAqB,wBAAA,EACrB,aAAA,EAAe,cAAA,KACd,OAAA,CAAQ,sBAAA"}
+{"version":3,"file":"writeMergedDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeMergedDictionary.ts"],"mappings":";;;;;KAiBY,sBAAA;EACV,cAAA;EACA,UAAA,EAAY,UAAA,GAAa,wBAAA;AAAA;AAAA,KAGf,sBAAA,GAAyB,MAAA,SAAe,sBAAA;;;;;;KAOxC,2BAAA;EACV,cAAA;EACA,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,2BAAA,GAA8B,MAAA,SAExC,2BAAA;;;AAPF;;;;;;;;;AAKA;;;;;cAqBa,uBAAA,GACX,mBAAA,EAAqB,wBAAA,EACrB,aAAA,EAAe,cAAA,KACd,OAAA,CAAQ,sBAAA"}

package/dist/types/createType/createType.d.ts

@@ -1,12 +1,12 @@
 import { IntlayerConfig } from "@intlayer/types/config";
-import { Dictionary } from "@intlayer/types/dictionary";
+import { Dictionary, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 
 //#region src/createType/createType.d.ts
-declare const generateTypeScriptType: (dictionary: Dictionary) => string;
+declare const generateTypeScriptType: (dictionary: Dictionary | QualifiedDictionaryGroup) => string;
 /**
  * This function generates a TypeScript type definition from a JSON object
  */
-declare const createTypes: (dictionaries: Dictionary[], configuration: IntlayerConfig) => Promise<string[]>;
+declare const createTypes: (dictionaries: (Dictionary | QualifiedDictionaryGroup)[], configuration: IntlayerConfig) => Promise<string[]>;
 //#endregion
 export { createTypes, generateTypeScriptType };
 //# sourceMappingURL=createType.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"createType.d.ts","names":[],"sources":["../../../src/createType/createType.ts"],"mappings":";;;;cAMa,sBAAA,GAA0B,UAAA,EAAY,UAAA;;AAAnD;;cAQa,WAAA,GACX,YAAA,EAAc,UAAA,IACd,aAAA,EAAe,cAAA,KACd,OAAA"}
+{"version":3,"file":"createType.d.ts","names":[],"sources":["../../../src/createType/createType.ts"],"mappings":";;;;cASa,sBAAA,GACX,UAAA,EAAY,UAAA,GAAa,wBAAA;;AAD3B;;cAUa,WAAA,GACX,YAAA,GAAe,UAAA,GAAa,wBAAA,KAC5B,aAAA,EAAe,cAAA,KACd,OAAA"}

package/dist/types/formatDictionary.d.ts

@@ -1,3 +1,4 @@
+import { LocalesValues } from "./intlayer/dist/types/index.js";
 import { Dictionary } from "@intlayer/types/dictionary";
 import * as _$_intlayer_types0 from "@intlayer/types";
 import * as _$_intlayer_core_messageFormat0 from "@intlayer/core/messageFormat";
@@ -20,7 +21,10 @@ declare const formatDictionaryOutput: (dictionary: Dictionary, format: Dictionar
   version?: string;
   filePath?: string;
   tags?: string[];
-  locale?: _$_intlayer_types0.LocalesValues;
+  item?: number;
+  variant?: string;
+  meta?: _$_intlayer_types0.DictionaryMeta;
+  locale?: LocalesValues;
   contentAutoTransformation?: _$_intlayer_types0.ContentAutoTransformation;
   fill?: _$_intlayer_types0.Fill;
   filled?: true;
@@ -44,7 +48,10 @@ declare const formatDictionariesOutput: (dictionaries: Dictionary[], format: Dic
   version?: string;
   filePath?: string;
   tags?: string[];
-  locale?: _$_intlayer_types0.LocalesValues;
+  item?: number;
+  variant?: string;
+  meta?: _$_intlayer_types0.DictionaryMeta;
+  locale?: LocalesValues;
   contentAutoTransformation?: _$_intlayer_types0.ContentAutoTransformation;
   fill?: _$_intlayer_types0.Fill;
   filled?: true;

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

@@ -1 +1 @@
-{"version":3,"file":"formatDictionary.d.ts","names":[],"sources":["../../src/formatDictionary.ts"],"mappings":";;;;;cAYa,gBAAA,GAAoB,UAAA,EAAY,UAAA,KAAa,UAAA;AAAA,cAoC7C,kBAAA,GACX,YAAA,EAAc,UAAA,OACb,OAAA,CAAQ,UAAA;AAAA,cAEE,sBAAA,GACX,UAAA,EAAY,UAAA,EACZ,MAAA,EAAQ,UAAA,eAAoB,UAAA;;WAAA,+BAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;cAqCjB,wBAAA,GACX,YAAA,EAAc,UAAA,IACd,MAAA,EAAQ,UAAA,gBAAoB,UAAA;;WAAA,+BAAA,CAAA,SAAA"}
+{"version":3,"file":"formatDictionary.d.ts","names":[],"sources":["../../src/formatDictionary.ts"],"mappings":";;;;;;cAYa,gBAAA,GAAoB,UAAA,EAAY,UAAA,KAAa,UAAA;AAAA,cAoC7C,kBAAA,GACX,YAAA,EAAc,UAAA,OACb,OAAA,CAAQ,UAAA;AAAA,cAEE,sBAAA,GACX,UAAA,EAAY,UAAA,EACZ,MAAA,EAAQ,UAAA,eAAoB,UAAA;;WAAA,+BAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;cAqCjB,wBAAA,GACX,YAAA,EAAc,UAAA,IACd,MAAA,EAAQ,UAAA,gBAAoB,UAAA;;WAAA,+BAAA,CAAA,SAAA"}

package/dist/types/init/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/init/index.ts"],"mappings":";;AAkKA;;KAAY,WAAA;EACV,WAAA;AAAA;AAMF;;;AAAA,cAAa,YAAA,GAAsB,OAAA,UAAiB,OAAA,GAAU,WAAA,KAAW,OAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/init/index.ts"],"mappings":";;AA4KA;;KAAY,WAAA;EACV,WAAA;AAAA;AAMF;;;AAAA,cAAa,YAAA,GAAsB,OAAA,UAAiB,OAAA,GAAU,WAAA,KAAW,OAAA"}

package/dist/types/init/utils/configManipulation.d.ts

@@ -1,8 +1,49 @@
+import { CompatSyncConfig, CompatVitePluginConfig } from "./packageManager.js";
+
 //#region src/init/utils/configManipulation.d.ts
 declare const updateViteConfig: (content: string, extension: string) => string;
 declare const updateAstroConfig: (content: string, extension: string) => string;
 declare const updateNextConfig: (content: string, extension: string) => string;
 declare const updateNuxtConfig: (content: string) => string;
+/**
+ * Updates a Vite config for vue-i18n compat: injects `vueI18nVitePlugin` from
+ * `@intlayer/vue-i18n/plugin` into the plugins array.
+ */
+declare const updateViteConfigForVueI18n: (content: string, extension: string) => string;
+/**
+ * Generic vite config updater for any compat plugin that uses alias injection.
+ * Injects the named import from `pluginPackageSource` and appends the plugin
+ * call to the `plugins` array.
+ */
+declare const updateViteConfigForCompatPlugin: (content: string, extension: string, pluginConfig: CompatVitePluginConfig) => string;
+/**
+ * Updates a Next.js config for next-translate compat: wraps the default export
+ * with `withNextTranslate` from `@intlayer/next-translate/plugin`.
+ */
+declare const updateNextConfigForNextTranslate: (content: string, extension: string) => string;
+/**
+ * Updates a Nuxt config for nuxtjs-i18n compat: adds `@intlayer/nuxtjs-i18n`
+ * to the `modules` array.
+ */
+declare const updateNuxtConfigForNuxtjsI18n: (content: string) => string;
+/**
+ * Updates a Next.js config for next-i18next compat: wraps the default export
+ * with `withI18next` from `@intlayer/next-i18next/plugin`.
+ */
+declare const updateNextConfigForNextI18next: (content: string, extension: string) => string;
+/**
+ * Updates a Next.js config for next-intl compat: replaces any existing
+ * `next-intl/plugin` import source with `@intlayer/next-intl/plugin`, or
+ * injects `createNextIntlPlugin` with a factory-call wrapper when no such
+ * import is present.
+ */
+declare const updateNextConfigForNextIntl: (content: string, extension: string) => string;
+/**
+ * Injects the syncJSON import and a configured syncJSON(...) call into the
+ * plugins array of an intlayer config file. Idempotent: skips when
+ * @intlayer/sync-json-plugin is already imported.
+ */
+declare const updateIntlayerConfigWithSyncPlugin: (content: string, extension: string, syncConfig: CompatSyncConfig) => string;
 //#endregion
-export { updateAstroConfig, updateNextConfig, updateNuxtConfig, updateViteConfig };
+export { updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n };
 //# sourceMappingURL=configManipulation.d.ts.map

package/dist/types/init/utils/configManipulation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configManipulation.d.ts","names":[],"sources":["../../../../src/init/utils/configManipulation.ts"],"mappings":";cAoKa,gBAAA,GACX,OAAA,UACA,SAAA;AAAA,cAmBW,iBAAA,GACX,OAAA,UACA,SAAA;AAAA,cAmBW,gBAAA,GACX,OAAA,UACA,SAAA;AAAA,cAoDW,gBAAA,GAAoB,OAAA"}
+{"version":3,"file":"configManipulation.d.ts","names":[],"sources":["../../../../src/init/utils/configManipulation.ts"],"mappings":";;;cAwKa,gBAAA,GACX,OAAA,UACA,SAAA;AAAA,cAmBW,iBAAA,GACX,OAAA,UACA,SAAA;AAAA,cAmBW,gBAAA,GACX,OAAA,UACA,SAAA;AAAA,cAoDW,gBAAA,GAAoB,OAAA;;;;AA3EjC;cAwIa,0BAAA,GACX,OAAA,UACA,SAAA;;;;AArHF;;cAkJa,+BAAA,GACX,OAAA,UACA,SAAA,UACA,YAAA,EAAc,sBAAA;;;AA/FhB;;cAyLa,gCAAA,GACX,OAAA,UACA,SAAA;;;AA9HF;;cA2Ia,6BAAA,GAAiC,OAAA;;;AA5G9C;;cA2Ka,8BAAA,GACX,OAAA,UACA,SAAA;;;;;;;cAeW,2BAAA,GACX,OAAA,UACA,SAAA;AAjGF;;;;;AAAA,cAsSa,kCAAA,GACX,OAAA,UACA,SAAA,UACA,UAAA,EAAY,gBAAA"}

package/dist/types/init/utils/fileSystem.d.ts

@@ -15,6 +15,36 @@ declare const writeFileToRoot: (rootDir: string, filePath: string, content: stri
  * Helper to ensure a directory exists
  */
 declare const ensureDirectory: (rootDir: string, dirPath: string) => Promise<void>;
+/**
+ * Pattern type for locale JSON file organisation.
+ * - 'nested': files are at `{base}/{locale}/{key}.json`
+ * - 'flat':   files are at `{base}/{locale}.json`
+ */
+type JsonLocalePatternType = 'nested' | 'flat';
+/**
+ * Detected locale JSON file pattern and the corresponding source template.
+ * `template` uses `${locale}` and `${key}` as literal placeholders (not JS
+ * expressions) so it can be embedded directly in a template-literal string.
+ */
+type JsonLocalePattern = {
+  type: JsonLocalePatternType;
+  /**
+   * Source path template for syncJSON `source` option.
+   * Example nested: `./locales/${locale}/${key}.json`
+   * Example flat:   `./locales/${locale}.json`
+   */
+  template: string;
+};
+/**
+ * Scans the project for JSON files and determines whether locale files are
+ * organised as `{base}/{locale}/{key}.json` (nested) or `{base}/{locale}.json`
+ * (flat).  Returns the most likely source template, or `null` when no locale
+ * JSON files are found.
+ *
+ * The returned `template` contains `${locale}` and `${key}` as **literal**
+ * placeholder strings so it can be embedded inside a JS template literal.
+ */
+declare const detectJsonLocalePattern: (rootDir: string) => Promise<JsonLocalePattern | null>;
 //#endregion
-export { ensureDirectory, exists, readFileFromRoot, writeFileToRoot };
+export { JsonLocalePattern, JsonLocalePatternType, detectJsonLocalePattern, ensureDirectory, exists, readFileFromRoot, writeFileToRoot };
 //# sourceMappingURL=fileSystem.d.ts.map

package/dist/types/init/utils/fileSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fileSystem.d.ts","names":[],"sources":["../../../../src/init/utils/fileSystem.ts"],"mappings":";;AAMA;;cAAa,MAAA,GAAgB,OAAA,UAAiB,QAAA,aAAgB,OAAA;;;;cAYjD,gBAAA,GAA0B,OAAA,UAAiB,QAAA,aAAgB,OAAA;;;AAAxE;cAMa,eAAA,GACX,OAAA,UACA,QAAA,UACA,OAAA,aAAe,OAAA;;;;cAMJ,eAAA,GAAyB,OAAA,UAAiB,OAAA,aAAe,OAAA"}
+{"version":3,"file":"fileSystem.d.ts","names":[],"sources":["../../../../src/init/utils/fileSystem.ts"],"mappings":";;AASA;;cAAa,MAAA,GAAgB,OAAA,UAAiB,QAAA,aAAgB,OAAA;;;;cAYjD,gBAAA,GAA0B,OAAA,UAAiB,QAAA,aAAgB,OAAA;;;AAAxE;cAMa,eAAA,GACX,OAAA,UACA,QAAA,UACA,OAAA,aAAe,OAAA;;;;cAMJ,eAAA,GAAyB,OAAA,UAAiB,OAAA,aAAe,OAAA;;;;AATtE;;KAsBY,qBAAA;;;;;;KAOA,iBAAA;EACV,IAAA,EAAM,qBAAA;EArBK;;;;;EA2BX,QAAA;AAAA;;;AAdF;;;;;AAOA;;cAmDa,uBAAA,GACX,OAAA,aACC,OAAA,CAAQ,iBAAA"}

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

@@ -1,5 +1,6 @@
-import { updateAstroConfig, updateNextConfig, updateNuxtConfig, updateViteConfig } from "./configManipulation.js";
-import { ensureDirectory, exists, readFileFromRoot, writeFileToRoot } from "./fileSystem.js";
+import { CompatSyncConfig, CompatVitePluginConfig, IntlayerPackageAnalysis, PackageManager, detectMissingIntlayerPackages, detectPackageManager, installPackages } from "./packageManager.js";
+import { updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n } from "./configManipulation.js";
+import { JsonLocalePattern, JsonLocalePatternType, detectJsonLocalePattern, ensureDirectory, exists, readFileFromRoot, writeFileToRoot } from "./fileSystem.js";
 import { parseJSONWithComments } from "./jsonParser.js";
 import { findTsConfigFiles } from "./tsConfig.js";
-export { ensureDirectory, exists, findTsConfigFiles, parseJSONWithComments, readFileFromRoot, updateAstroConfig, updateNextConfig, updateNuxtConfig, updateViteConfig, writeFileToRoot };
+export { CompatSyncConfig, CompatVitePluginConfig, IntlayerPackageAnalysis, JsonLocalePattern, JsonLocalePatternType, PackageManager, detectJsonLocalePattern, detectMissingIntlayerPackages, detectPackageManager, ensureDirectory, exists, findTsConfigFiles, installPackages, parseJSONWithComments, readFileFromRoot, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n, writeFileToRoot };

package/dist/types/init/utils/packageManager.d.ts

@@ -0,0 +1,59 @@
+//#region src/init/utils/packageManager.d.ts
+/** Package managers supported for dependency installation. */
+type PackageManager = 'bun' | 'pnpm' | 'yarn' | 'npm';
+/**
+ * Configuration for the syncJSON plugin injected into intlayer.config
+ * when a compat i18n library is detected.
+ */
+type CompatSyncConfig = {
+  /** JSON format matching the compat library's conventions. */format: 'icu' | 'i18next' | 'vue-i18n';
+  /**
+   * Source path template using ${locale} and ${key} placeholders.
+   * Rendered as a template literal in the generated config.
+   */
+  sourceTemplate: string;
+};
+/**
+ * Configuration for injecting a compat vite plugin into vite.config.
+ * The plugin replaces the generic `intlayer` plugin for libraries that
+ * require alias injection (e.g. `vue-i18n` → `@intlayer/vue-i18n`).
+ */
+type CompatVitePluginConfig = {
+  /** Exported function name from the plugin package, e.g. `'vueI18nVitePlugin'`. */pluginFunctionName: string; /** Import path for the plugin package, e.g. `'@intlayer/vue-i18n/plugin'`. */
+  pluginPackageSource: string;
+};
+/** Result of analyzing project dependencies for intlayer package gaps. */
+type IntlayerPackageAnalysis = {
+  /** Intlayer packages that are referenced but not yet installed. */packagesToInstall: string[];
+  /**
+   * syncJSON plugin configuration to inject when a compat i18n library is
+   * detected. Undefined when no compat library is present or format is not
+   * yet implemented.
+   */
+  compatSyncConfig: CompatSyncConfig | undefined;
+  /**
+   * Vite config plugin to inject when a vite-based compat library is
+   * detected. Undefined for Next.js/Nuxt-only compat libs or when no compat
+   * library requires alias injection.
+   */
+  compatVitePluginConfig: CompatVitePluginConfig | undefined;
+};
+/**
+ * Detects the package manager in use by checking for lock files in the
+ * project root. Falls back to npm when no lock file is found.
+ */
+declare const detectPackageManager: (rootDir: string) => PackageManager;
+/**
+ * Analyzes existing project dependencies to determine which intlayer packages
+ * are missing and what syncJSON configuration to inject when compat i18n
+ * libraries are present.
+ */
+declare const detectMissingIntlayerPackages: (allDependencies: Record<string, string>) => IntlayerPackageAnalysis;
+/**
+ * Runs the package install command synchronously.
+ * Throws if the install process exits with a non-zero code.
+ */
+declare const installPackages: (rootDir: string, packages: string[], packageManager: PackageManager) => void;
+//#endregion
+export { CompatSyncConfig, CompatVitePluginConfig, IntlayerPackageAnalysis, PackageManager, detectMissingIntlayerPackages, detectPackageManager, installPackages };
+//# sourceMappingURL=packageManager.d.ts.map

package/dist/types/init/utils/packageManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageManager.d.ts","names":[],"sources":["../../../../src/init/utils/packageManager.ts"],"mappings":";;KAKY,cAAA;;;;;KAMA,gBAAA;EAAgB,6DAE1B,MAAA;EAAA;;AAaF;;EARE,cAAA;AAAA;;AAgBF;;;;KARY,sBAAA;EAgBV,kFAdA,kBAAA,UAoBA;EAlBA,mBAAA;AAAA;;KAIU,uBAAA;EAmCX,mEAjCC,iBAAA;EAmBmC;;AAyCrC;;;EAtDE,gBAAA,EAAkB,gBAAA;EAuDD;;;;;EAjDjB,sBAAA,EAAwB,sBAAA;AAAA;;;;;cAOb,oBAAA,GAAwB,OAAA,aAAkB,cAAA;;;;;;cAyC1C,6BAAA,GACX,eAAA,EAAiB,MAAA,qBAChB,uBAAA;;;;;cAwNU,eAAA,GACX,OAAA,UACA,QAAA,YACA,cAAA,EAAgB,cAAA"}

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

@@ -0,0 +1,4 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+import { Dictionary } from "@intlayer/types/dictionary";
+import { LocalesValues as LocalesValues$1 } from "@intlayer/types/module_augmentation";
+export { type LocalesValues$1 as LocalesValues };

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

@@ -0,0 +1,16 @@
+import { BundleChunkInput, BundleContentAnalysis } from "./types.js";
+
+//#region src/scan/analyzeBundleContent.d.ts
+/**
+ * Analyze the locale weight of a page's JavaScript bundles.
+ *
+ * @param chunks - The fetched JavaScript chunks (main + lazy).
+ * @param htmlContent - The page HTML, used to estimate rendered content size.
+ * @param currentLocale - The locale currently rendered by the page.
+ * @param totalPageSize - The total transferred bytes measured for the page.
+ * @returns The aggregated {@link BundleContentAnalysis}.
+ */
+declare const analyzeBundleContent: (chunks: BundleChunkInput[], htmlContent: string, currentLocale: string, totalPageSize: number) => BundleContentAnalysis;
+//#endregion
+export { analyzeBundleContent };
+//# sourceMappingURL=analyzeBundleContent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyzeBundleContent.d.ts","names":[],"sources":["../../../src/scan/analyzeBundleContent.ts"],"mappings":";;;;;AA6KA;;;;;;;cAAa,oBAAA,GACX,MAAA,EAAQ,gBAAA,IACR,WAAA,UACA,aAAA,UACA,aAAA,aACC,qBAAA"}

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

@@ -0,0 +1,65 @@
+//#region src/scan/calculateScore.d.ts
+/**
+ * Mutualized SEO/i18n scoring logic.
+ *
+ * This module is the single source of truth for turning audit/scan events into
+ * a weighted score. It is consumed both by the hosted backend SEO audit
+ * (`apps/backend`) and by the `intlayer scan` CLI command, so it must stay free
+ * of any server-only dependency (no Fastify, no Cheerio, no logger coupling).
+ */
+/** Accumulated score across all checks that ran. */
+type Score = {
+  /** Sum of points obtained (success = full, warning = half, error = none). */score: number; /** Maximum achievable points for the checks that ran. */
+  totalScore: number;
+};
+/**
+ * Minimal shape of an event needed to contribute to the score.
+ *
+ * The `type` is the check identifier. URL-scoped checks are suffixed with the
+ * URL using a backslash separator (e.g. `url_htmlLang\https://example.com`), so
+ * only the part before the first backslash is used to look up the weight.
+ */
+type ScorableEvent = {
+  type?: string;
+  status?: string;
+};
+/** Weight (in points) of every scorable check. */
+declare const scoreRecord: {
+  readonly robots_robotsPresent: 10;
+  readonly robots_noLocalizedUrlsForgotten: 8;
+  readonly sitemap_sitemapPresent: 10;
+  readonly sitemap_noLocalizedUrlsForgotten: 9;
+  readonly sitemap_hasAlternates: 8;
+  readonly sitemap_hasXDefault: 7;
+  readonly url_htmlLang: 9;
+  readonly url_htmlDir: 3;
+  readonly url_hasCanonical: 10;
+  readonly url_hreflang: 9;
+  readonly url_hasLocalizedLinks: 8;
+  readonly url_hasXDefault: 7;
+  readonly url_allAnchorsLocalized: 6;
+  readonly url_currentLocale: 3;
+  readonly url_unusedBundleContent: 8;
+};
+/** Identifier of a scorable check (without the URL suffix). */
+type ScoreCheckType = keyof typeof scoreRecord;
+/**
+ * Apply a single event to the running score, returning a new {@link Score}.
+ * Unknown check types are ignored so the function is safe to call on every
+ * emitted event.
+ *
+ * @param score - The current accumulated score.
+ * @param event - The event to fold into the score.
+ * @returns A new score with the event applied.
+ */
+declare const mutateScore: (score: Score, event: ScorableEvent) => Score;
+/**
+ * Convert a raw {@link Score} into a 0–100 percentage.
+ *
+ * @param score - The accumulated score.
+ * @returns The rounded percentage, or 0 when no check ran.
+ */
+declare const toScorePercent: (score: Score) => number;
+//#endregion
+export { ScorableEvent, Score, ScoreCheckType, mutateScore, scoreRecord, toScorePercent };
+//# sourceMappingURL=calculateScore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"calculateScore.d.ts","names":[],"sources":["../../../src/scan/calculateScore.ts"],"mappings":";;AAUA;;;;;AAcA;;;KAdY,KAAA;EAgBJ,6EAdN,KAAA,UA8CQ;EA5CR,UAAA;AAAA;;;;;;;;KAUU,aAAA;EACV,IAAA;EACA,MAAA;AAAA;;cAgBW,WAAA;EAAA;;;;;;;;;;;;;;;;;KAmBD,cAAA,gBAA8B,WAAA;;;;;;;AAoC1C;;;cAzBa,WAAA,GAAe,KAAA,EAAO,KAAA,EAAO,KAAA,EAAO,aAAA,KAAgB,KAAA;;;;;;;cAyBpD,cAAA,GAAkB,KAAA,EAAO,KAAA"}

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

@@ -0,0 +1,38 @@
+import { BundleChunkInput, BundleContentAnalysis, ScanEvent } from "./types.js";
+import { Anchor } from "./parseHtml.js";
+
+//#region src/scan/checks.d.ts
+/** Format a byte count as a human-readable size. */
+declare const formatSize: (bytes: number) => string;
+/**
+ * Check the `<html>` element attributes (`lang`, `dir`) and the resulting
+ * current-locale signal. Returns the detected language tag.
+ */
+declare const checkHtmlAttributes: (html: string, targetUrl: string, events: ScanEvent[]) => {
+  langTag: string | undefined;
+};
+/** Check the presence of a canonical link. */
+declare const checkCanonical: (html: string, targetUrl: string, events: ScanEvent[]) => void;
+/**
+ * Check the page's hreflang structure and collect discovered locales into
+ * `localesSet`.
+ */
+declare const checkLinguisticStructure: (html: string, targetUrl: string, localesSet: Set<string>, events: ScanEvent[]) => void;
+/**
+ * Check whether internal links carry a locale segment, mirroring the hosted
+ * audit's URL-structure analysis but operating on parsed anchors instead of a
+ * live DOM.
+ */
+declare const checkUrlStructure: (anchors: Anchor[], origin: string, targetUrl: string, events: ScanEvent[]) => void;
+/**
+ * Analyze the JavaScript bundles for unused locale content and emit the
+ * corresponding event. Returns the analysis so callers can report on it.
+ */
+declare const checkBundleContent: (chunks: BundleChunkInput[], html: string, currentLocale: string | undefined, targetUrl: string, totalPageSize: number, events: ScanEvent[]) => BundleContentAnalysis | undefined;
+/** Fetch and check `robots.txt`, emitting robots-related events. */
+declare const checkRobots: (origin: string, discoveredLocales: Set<string>, userAgent: string, events: ScanEvent[]) => Promise<void>;
+/** Fetch and check `sitemap.xml`, emitting sitemap-related events. */
+declare const checkSitemap: (origin: string, discoveredLocales: Set<string>, userAgent: string, events: ScanEvent[]) => Promise<void>;
+//#endregion
+export { checkBundleContent, checkCanonical, checkHtmlAttributes, checkLinguisticStructure, checkRobots, checkSitemap, checkUrlStructure, formatSize };
+//# sourceMappingURL=checks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.ts","names":[],"sources":["../../../src/scan/checks.ts"],"mappings":";;;;;cAgBa,UAAA,GAAc,KAAA;AAA3B;;;;AAAA,cAUa,mBAAA,GACX,IAAA,UACA,SAAA,UACA,MAAA,EAAQ,SAAA;EACL,OAAA;AAAA;;cAmCQ,cAAA,GACX,IAAA,UACA,SAAA,UACA,MAAA,EAAQ,SAAA;;;;;cAcG,wBAAA,GACX,IAAA,UACA,SAAA,UACA,UAAA,EAAY,GAAA,UACZ,MAAA,EAAQ,SAAA;;;AArBV;;;cA6Da,iBAAA,GACX,OAAA,EAAS,MAAA,IACT,MAAA,UACA,SAAA,UACA,MAAA,EAAQ,SAAA;;;;;cAwEG,kBAAA,GACX,MAAA,EAAQ,gBAAA,IACR,IAAA,UACA,aAAA,sBACA,SAAA,UACA,aAAA,UACA,MAAA,EAAQ,SAAA,OACP,qBAAA;;cA0CU,WAAA,GACX,MAAA,UACA,iBAAA,EAAmB,GAAA,UACnB,SAAA,UACA,MAAA,EAAQ,SAAA,OACP,OAAA;;cA0DU,YAAA,GACX,MAAA,UACA,iBAAA,EAAmB,GAAA,UACnB,SAAA,UACA,MAAA,EAAQ,SAAA,OACP,OAAA"}

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

@@ -0,0 +1,7 @@
+import { ScorableEvent, Score, ScoreCheckType, mutateScore, scoreRecord, toScorePercent } from "./calculateScore.js";
+import { BundleChunkInput, BundleContentAnalysis, ChunkAnalysis, 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 { 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 };

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

@@ -0,0 +1,54 @@
+//#region src/scan/parseHtml.d.ts
+/**
+ * Tiny dependency-free HTML extraction helpers.
+ *
+ * The hosted backend audit relies on Cheerio + a real browser, but the CLI scan
+ * must stay dependency-light. These regex-based helpers cover the handful of
+ * head/anchor signals the score needs. They are intentionally forgiving: when a
+ * tag can't be parsed it is simply skipped rather than throwing.
+ */
+/** Compute the UTF-8 byte length of a string in both Node and browser builds. */
+declare const byteLength: (text: string) => number;
+/** Extract the `lang` attribute of the `<html>` element, if present. */
+declare const extractHtmlLang: (html: string) => string | undefined;
+/** Extract the `dir` attribute of the `<html>` element, if present. */
+declare const extractHtmlDir: (html: string) => string | undefined;
+/** Extract the document `<title>` text. */
+declare const extractTitle: (html: string) => string;
+/** Extract the `<meta name="description">` content. */
+declare const extractMetaDescription: (html: string) => string;
+/** Extract the `<meta property="og:image">` content. */
+declare const extractOgImage: (html: string) => string | undefined;
+/** Whether a `<link rel="canonical">` element is present. */
+declare const hasCanonical: (html: string) => boolean;
+/** A parsed `<link rel="alternate" hreflang>` element. */
+type HreflangLink = {
+  hreflang: string;
+  href: string;
+};
+/** Extract every `<link rel="alternate" hreflang="…" href="…">` element. */
+declare const extractHreflangs: (html: string) => HreflangLink[];
+/**
+ * Extract every eagerly-loaded script URL: `<script src>`,
+ * `<link rel="modulepreload">` and `<link rel="preload" as="script">`.
+ *
+ * @param html - The raw HTML document.
+ * @param baseUrl - Base URL used to resolve relative script URLs.
+ * @returns Absolute, de-duplicated script URLs.
+ */
+declare const extractScriptUrls: (html: string, baseUrl: string) => string[];
+/** A parsed `<a href>` anchor. */
+type Anchor = {
+  href: string;
+  text: string;
+};
+/** Extract every `<a href="…">text</a>` anchor from the document. */
+declare const extractAnchors: (html: string) => Anchor[];
+/**
+ * Extract visible text snippets from an HTML document (scripts, styles and
+ * tags stripped). Used to approximate the rendered content size without a DOM.
+ */
+declare const extractVisibleTextStrings: (html: string) => string[];
+//#endregion
+export { Anchor, HreflangLink, byteLength, extractAnchors, extractHreflangs, extractHtmlDir, extractHtmlLang, extractMetaDescription, extractOgImage, extractScriptUrls, extractTitle, extractVisibleTextStrings, hasCanonical };
+//# sourceMappingURL=parseHtml.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parseHtml.d.ts","names":[],"sources":["../../../src/scan/parseHtml.ts"],"mappings":";;AAUA;;;;;AAkBA;;;cAlBa,UAAA,GAAc,IAAA;;cAkBd,eAAA,GAAmB,IAAA;;cAMnB,cAAA,GAAkB,IAAA;;cAMlB,YAAA,GAAgB,IAAA;AAA7B;AAAA,cAMa,sBAAA,GAA0B,IAAA;;cAW1B,cAAA,GAAkB,IAAA;;cAWlB,YAAA,GAAgB,IAAA;;KAMjB,YAAA;EAAiB,QAAA;EAAkB,IAAA;AAAA;;cAGlC,gBAAA,GAAoB,IAAA,aAAe,YAAA;;;AAThD;;;;;AAMA;cAuBa,iBAAA,GAAqB,IAAA,UAAc,OAAA;;KA4BpC,MAAA;EAAW,IAAA;EAAc,IAAA;AAAA;;cAGxB,cAAA,GAAkB,IAAA,aAAe,MAAA;;AA/B9C;;;cAqDa,yBAAA,GAA6B,IAAA"}

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

@@ -0,0 +1,18 @@
+import { ScanOptions, ScanResult } from "./types.js";
+
+//#region src/scan/scanWebsite.d.ts
+/**
+ * Scan a single web page for i18n/SEO health and bundle weight.
+ *
+ * In `deep` mode (default) the page is rendered with a locally installed
+ * `puppeteer`; when `puppeteer` is missing the scan transparently falls back to
+ * a `basic` fetch-based pass and logs a recommendation to install it.
+ *
+ * @param targetUrl - The absolute URL to scan.
+ * @param options - {@link ScanOptions} controlling depth, timeout and UA.
+ * @returns The {@link ScanResult} including score, page size and per-check events.
+ */
+declare const scanWebsite: (targetUrl: string, options?: ScanOptions) => Promise<ScanResult>;
+//#endregion
+export { scanWebsite };
+//# sourceMappingURL=scanWebsite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scanWebsite.d.ts","names":[],"sources":["../../../src/scan/scanWebsite.ts"],"mappings":";;;;;AAmNA;;;;;;;;;cAAa,WAAA,GACX,SAAA,UACA,OAAA,GAAS,WAAA,KACR,OAAA,CAAQ,UAAA"}