@intlayer/engine 9.5.10 → 9.5.12

package/dist/types/cli.d.ts

@@ -7,7 +7,7 @@ import { writeJSFile } from "./writeContentDeclaration/writeJSFile.js";
 import "./writeContentDeclaration/index.js";
 import { detectFormatCommand } from "./detectFormatCommand.js";
 import { getContentDeclarationFileTemplate } from "./getContentDeclarationFileTemplate/getContentDeclarationFileTemplate.js";
-import { COMPAT_I18N_LIBRARIES, CompatI18nLibrary, PackageManager, detectCompatI18nLibraries, detectPackageManager, hasLintTooling, installPackages } from "./init/utils/packageManager.js";
+import { COMPAT_I18N_LIBRARIES, CompatI18nLibrary, PackageManager, detectCompatI18nLibraries, detectPackageManager, findLockFileDir, hasLintTooling, installPackages } from "./init/utils/packageManager.js";
 import { RoutingMode } from "./init/utils/configManipulation.js";
 import { CmsCredentials, enableEditorInConfig, setupCmsCredentials, writeCmsCredentialsToEnv } from "./init/cms.js";
 import { DocumentationRouter, DocumentationRouterType, getDocumentationUrl } from "./init/documentationRouter.js";
@@ -23,4 +23,4 @@ import { listDictionaries, listDictionariesWithStats } from "./listDictionariesP
 import { DiffMode, ListGitFilesOptions, ListGitLinesOptions, listGitFiles, listGitLines } from "./listGitFiles.js";
 import { ListProjectsOptions, getGitRootDir, listProjects } from "./listProjects.js";
 import { logConfigDetails } from "./logConfigDetails.js";
-export { COMPAT_I18N_LIBRARIES, type CmsCredentials, type CompatI18nLibrary, ContentStrategy, DictionaryStatus, DiffMode, DocumentationRouter, type DocumentationRouterType, InitOptions, ListGitFilesOptions, ListGitLinesOptions, ListProjectsOptions, MCPTransport, NEXT_INTLAYER_BABEL_CONFIG_CONTENT, PLATFORMS, PLATFORMS_METADATA, type PackageManager, Platform, PlatformMetadata, type RoutingMode, SKILLS, SKILLS_METADATA, Skill, UpgradeIntlayerPackagesOptions, UpgradeIntlayerPackagesResult, detectCompatI18nLibraries, detectExportedComponentName, detectFormatCommand, detectPackageManager, enableEditorInConfig, getContentDeclarationFileTemplate, getDefaultApplicationURL, getDocumentationUrl, getGitRootDir, getInitialSkills, hasLintTooling, hasUrlRoutingFramework, initIntlayer, installLSP, installMCP, installPackages, installSkills, listDictionaries, listDictionariesWithStats, listGitFiles, listGitLines, listProjects, logConfigDetails, logInitSuccessMessage, prepareIntlayer, setupCmsCredentials, transformJSFile, upgradeIntlayerPackages, writeCmsCredentialsToEnv, writeContentDeclaration, writeJSFile };
+export { COMPAT_I18N_LIBRARIES, type CmsCredentials, type CompatI18nLibrary, ContentStrategy, DictionaryStatus, DiffMode, DocumentationRouter, type DocumentationRouterType, InitOptions, ListGitFilesOptions, ListGitLinesOptions, ListProjectsOptions, MCPTransport, NEXT_INTLAYER_BABEL_CONFIG_CONTENT, PLATFORMS, PLATFORMS_METADATA, type PackageManager, Platform, PlatformMetadata, type RoutingMode, SKILLS, SKILLS_METADATA, Skill, UpgradeIntlayerPackagesOptions, UpgradeIntlayerPackagesResult, detectCompatI18nLibraries, detectExportedComponentName, detectFormatCommand, detectPackageManager, enableEditorInConfig, findLockFileDir, getContentDeclarationFileTemplate, getDefaultApplicationURL, getDocumentationUrl, getGitRootDir, getInitialSkills, hasLintTooling, hasUrlRoutingFramework, initIntlayer, installLSP, installMCP, installPackages, installSkills, listDictionaries, listDictionariesWithStats, listGitFiles, listGitLines, listProjects, logConfigDetails, logInitSuccessMessage, prepareIntlayer, setupCmsCredentials, transformJSFile, upgradeIntlayerPackages, writeCmsCredentialsToEnv, writeContentDeclaration, writeJSFile };

package/dist/types/docReview/rebuildDocument.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rebuildDocument.d.ts","names":[],"sources":["../../../src/docReview/rebuildDocument.ts"],"mappings":";;;;;;YAMY;;EAEV,WAAW;;EAEX;;EAEA;;YAGU;EACV,YAAY;EACZ,cAAc;EACd,MAAM;;YAGI;EACV,kBAAkB;;;;;;;;;;qBAWP,6BAAwB,YAAA,cAAA,QAIlC,iBAAe;;;;;;;;;;qBAmDL,wBAAqB,MAC1B,eAAa,cACL,sBAAoB,kBAChB"}
+{"version":3,"file":"rebuildDocument.d.ts","names":[],"sources":["../../../src/docReview/rebuildDocument.ts"],"mappings":";;;;;;YAMY;;EAEV,WAAW;;EAEX;;EAEA;;YAGU;EACV,YAAY;EACZ,cAAc;EACd,MAAM;;YAGI;EACV,kBAAkB;;;;;;;;;;qBAWP,6BAAwB,YAAA,cAAA,QAIlC,iBAAe;;;;;;;;;;qBAwDL,wBAAqB,MAC1B,eAAa,cACL,sBAAoB,kBAChB"}

package/dist/types/docReview/segmentDocument.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segmentDocument.d.ts","names":[],"sources":["../../../src/docReview/segmentDocument.ts"],"mappings":";;;;;;;;;;;;;;;;qBAoDa,kBAAe,iBAAmB;;;;;;;;;;;;;;;;;;;qBAuIlC,kBAAe,iBAAmB"}
+{"version":3,"file":"segmentDocument.d.ts","names":[],"sources":["../../../src/docReview/segmentDocument.ts"],"mappings":";;;;;;;;;;;;;;;;qBAuDa,kBAAe,iBAAmB;;;;;;;;;;;;;;;;;;;qBAwIlC,kBAAe,iBAAmB"}

package/dist/types/init/frameworkSetup/nextAppRouter/transforms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/transforms.ts"],"mappings":";;YAWY;EACV;EACA;;;YA4KU;;;;;;EAMV;;;;;;;;;;;;;qBAcW,yBAAsB,gBACrB,uBACmB,sBAC9B"}
+{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/transforms.ts"],"mappings":";;YAWY;EACV;EACA;;;YA6KU;;;;;;EAMV;;;;;;;;;;;;;qBAcW,yBAAsB,gBACrB,uBACmB,sBAC9B"}

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

@@ -39,7 +39,7 @@ export type InitOptions = {
   noEslint?: boolean;
   /**
    * Skip the project setup: tsconfig types/aliases, the Intlayer config file,
-   * bundler/framework configs, the dev script and framework-specific
+   * bundler/framework configs and framework-specific
    * scaffolding (middleware/proxy, providers in layout/page). Defaults to
    * enabled.
    */

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/init/index.ts"],"mappings":";;;;;;;;;;qBA6Ea,2BAAwB,cACrB;;;;;;;;;;YAsBJ;;;;YAQA;EACV;;EAEA;;;;;EAKA;;EAEA;;EAEA;;EAEA;;;;;;;EAOA;;EAEA;;;;;;EAMA;;;;;;EAMA,cAAc;;;;;;;EAOd;;;;;;;EAOA,kBAAkB;;;;;qBAMP,eAAY,iBAAyB,UAAY,gBAAW;;;qBA6kC5D,wBAAqB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/init/index.ts"],"mappings":";;;;;;;;;;qBA4Ea,2BAAwB,cACrB;;;;;;;;;;YAsBJ;;;;YAQA;EACV;;EAEA;;;;;EAKA;;EAEA;;EAEA;;EAEA;;;;;;;EAOA;;EAEA;;;;;;EAMA;;;;;;EAMA,cAAc;;;;;;;EAOd;;;;;;;EAOA,kBAAkB;;;;;qBAMP,eAAY,iBAAyB,UAAY,gBAAW;;;qBAqjC5D,wBAAqB"}

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

@@ -0,0 +1,5 @@
+//#region src/init/utils/backendPackages.d.ts
+/** Intlayer integrations for server frameworks (no bundler plugin). */
+export declare const BACKEND_INTLAYER_PACKAGES: string[];
+//#endregion
+//# sourceMappingURL=backendPackages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"backendPackages.d.ts","names":[],"sources":["../../../../src/init/utils/backendPackages.ts"],"mappings":";;qBACa"}

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

@@ -1,7 +1,7 @@
 import { COMPAT_I18N_LIBRARIES, COMPAT_PACKAGE_REPLACEMENTS, CompatI18nLibrary, CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, IntlayerPackageAnalysis, MINIMUM_ESLINT_MAJOR, PENDING_COMPAT_ADAPTERS, PackageManager, detectCompatI18nLibraries, detectMissingIntlayerPackages, detectPackageManager, findLockFileDir, hasLegacyEslint, hasLintTooling, installPackages, isIntlayerPackageName, moveCompatPackagesToDevDependencies, normalizeVersion, runPackageInstall } from "./packageManager.js";
 import { RoutingMode, enableIntlayerEditorConfig, getMetroConfigTemplate, hasIntlayerVitePlugin, replaceViteConfigPluginImportSource, setIntlayerConfigCompilerOutput, setIntlayerConfigEnableProxy, setIntlayerConfigRoutingMode, setIntlayerConfigRoutingStorageOnly, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n } from "./configManipulation.js";
 import { ensureNamedImport, firstInsertIndex, isModuleScopeBinding } from "./astImports.js";
-import { BACKEND_INTLAYER_PACKAGES, ResolveDevScriptParams, resolveDevScript } from "./devScript.js";
+import { BACKEND_INTLAYER_PACKAGES } from "./backendPackages.js";
 import { JsonLocalePattern, JsonLocalePatternType, LinguiCatalogPattern, NextIntlMessagesPattern, detectJsonLocalePattern, detectLinguiCatalogPattern, detectNextIntlMessagesPattern, ensureDirectory, exists, readFileFromRoot, writeFileToRoot } from "./fileSystem.js";
 import { GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, GithubWorkflowsContext, GithubWorkflowsOptions, getGithubWorkflows, resolveGithubWorkflowsContext } from "./githubActions.js";
 import { IntlayerDependency, IntlayerDependencyUpgrade, PackageJsonIntlayerDependencies, fetchLatestPackageVersion, findPackageJsonFiles, getIntlayerDependencies, getIntlayerDependencyUpgrades, listIntlayerDependencies, toRange, writeIntlayerDependencyUpgrades } from "./intlayerDependencies.js";
@@ -11,4 +11,4 @@ import { NEXT_INTLAYER_BABEL_CONFIG_CONTENT, setupNextCompilerBabelConfig } from
 import { findTsConfigFiles } from "./tsConfig.js";
 import { hasUrlRoutingFramework } from "./urlRoutingFramework.js";
 import { isVersionAtLeast } from "./version.js";
-export { BACKEND_INTLAYER_PACKAGES, COMPAT_I18N_LIBRARIES, COMPAT_PACKAGE_REPLACEMENTS, CompatI18nLibrary, CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, GithubWorkflowsContext, GithubWorkflowsOptions, IntlayerDependency, IntlayerDependencyUpgrade, IntlayerPackageAnalysis, JsonLocalePattern, JsonLocalePatternType, LINT_PLUGIN_PACKAGE_NAME, LinguiCatalogPattern, MINIMUM_ESLINT_MAJOR, NEXT_INTLAYER_BABEL_CONFIG_CONTENT, NextIntlMessagesPattern, OxlintConfig, PENDING_COMPAT_ADAPTERS, PackageJsonIntlayerDependencies, PackageManager, ResolveDevScriptParams, RoutingMode, addIntlayerRulesToOxlintConfig, detectCompatI18nLibraries, detectJsonLocalePattern, detectLinguiCatalogPattern, detectMissingIntlayerPackages, detectNextIntlMessagesPattern, detectPackageManager, enableIntlayerEditorConfig, ensureDirectory, ensureNamedImport, exists, fetchLatestPackageVersion, findLockFileDir, findPackageJsonFiles, findTsConfigFiles, firstInsertIndex, getGithubWorkflows, getIntlayerDependencies, getIntlayerDependencyUpgrades, getMetroConfigTemplate, hasIntlayerVitePlugin, hasLegacyEslint, hasLintTooling, hasUrlRoutingFramework, installPackages, isIntlayerPackageName, isModuleScopeBinding, isVersionAtLeast, listIntlayerDependencies, moveCompatPackagesToDevDependencies, normalizeVersion, parseJSONWithComments, readFileFromRoot, replaceViteConfigPluginImportSource, resolveDevScript, resolveGithubWorkflowsContext, runPackageInstall, setIntlayerConfigCompilerOutput, setIntlayerConfigEnableProxy, setIntlayerConfigRoutingMode, setIntlayerConfigRoutingStorageOnly, setupNextCompilerBabelConfig, toRange, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n, writeFileToRoot, writeIntlayerDependencyUpgrades };
+export { BACKEND_INTLAYER_PACKAGES, COMPAT_I18N_LIBRARIES, COMPAT_PACKAGE_REPLACEMENTS, CompatI18nLibrary, CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, GithubWorkflowsContext, GithubWorkflowsOptions, IntlayerDependency, IntlayerDependencyUpgrade, IntlayerPackageAnalysis, JsonLocalePattern, JsonLocalePatternType, LINT_PLUGIN_PACKAGE_NAME, LinguiCatalogPattern, MINIMUM_ESLINT_MAJOR, NEXT_INTLAYER_BABEL_CONFIG_CONTENT, NextIntlMessagesPattern, OxlintConfig, PENDING_COMPAT_ADAPTERS, PackageJsonIntlayerDependencies, PackageManager, RoutingMode, addIntlayerRulesToOxlintConfig, detectCompatI18nLibraries, detectJsonLocalePattern, detectLinguiCatalogPattern, detectMissingIntlayerPackages, detectNextIntlMessagesPattern, detectPackageManager, enableIntlayerEditorConfig, ensureDirectory, ensureNamedImport, exists, fetchLatestPackageVersion, findLockFileDir, findPackageJsonFiles, findTsConfigFiles, firstInsertIndex, getGithubWorkflows, getIntlayerDependencies, getIntlayerDependencyUpgrades, getMetroConfigTemplate, hasIntlayerVitePlugin, hasLegacyEslint, hasLintTooling, hasUrlRoutingFramework, installPackages, isIntlayerPackageName, isModuleScopeBinding, isVersionAtLeast, listIntlayerDependencies, moveCompatPackagesToDevDependencies, normalizeVersion, parseJSONWithComments, readFileFromRoot, replaceViteConfigPluginImportSource, resolveGithubWorkflowsContext, runPackageInstall, setIntlayerConfigCompilerOutput, setIntlayerConfigEnableProxy, setIntlayerConfigRoutingMode, setIntlayerConfigRoutingStorageOnly, setupNextCompilerBabelConfig, toRange, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n, writeFileToRoot, writeIntlayerDependencyUpgrades };

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

@@ -9,6 +9,7 @@ export declare const SKILLS_METADATA: {
   readonly Usage: 'How to use Intlayer in your project';
   readonly CLI: 'Intlayer CLI commands and usage';
   readonly Compiler: 'Intlayer Compiler setup and usage for automatic content extraction without .content files';
+  readonly BundleOptimization: 'Purge, minify and import modes; writing code the bundle optimizer can follow';
   readonly RemoteContent: 'How to use Intlayer with Remote/CMS/Server-side content';
   readonly DevTools: 'ESLint, LSP, VS Code & Chrome extensions, MCP server and CI/CD';
   readonly Compat: 'Migrate from i18next, next-intl, react-intl, vue-i18n, Lingui… keeping their API';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/installSkills/index.ts"],"mappings":";;;;qBASa;WACX;WACA;WACA;WAEA;WACA;WACA;WAEA;WACA;WACA;WAEA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;YAIU,qBAAqB;qBAEpB,QAAyC;;;;;;;qBAoFzC,mBAAgB,cACb,2BACb;iBAUc;EACf;EACA;EACA;;;;;qBAMW,oBAAoB,eAAe;YA6JpC,wBAAwB;qBAEvB,WAA+C;;;;;qBA8G/C,gBAAa,qBACL,UACT,UAAQ,QACV,YACP"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/installSkills/index.ts"],"mappings":";;;;qBASa;WACX;WACA;WACA;WAEA;WACA;WACA;WAEA;WAEA;WACA;WACA;WAEA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;YAIU,qBAAqB;qBAEpB,QAAyC;;;;;;;qBAqFzC,mBAAgB,cACb,2BACb;iBAUc;EACf;EACA;EACA;;;;;qBAMW,oBAAoB,eAAe;YA6JpC,wBAAwB;qBAEvB,WAA+C;;;;;qBA8G/C,gBAAa,qBACL,UACT,UAAQ,QACV,YACP"}

package/dist/types/loadDictionaries/loadRemoteDictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadRemoteDictionaries.d.ts","names":[],"sources":["../../../src/loadDictionaries/loadRemoteDictionaries.ts"],"mappings":";;;;qBAea,4BAAyB,eACrB,gBAAgB,kBAC9B;qBAOU,yBAAsB,0CAAA,gBAAA,kBAEf,QAAQ,+BAA6B;EAErD;EACA;EACA,WAAW,OAAO;MAEnB,QAAQ"}
+{"version":3,"file":"loadRemoteDictionaries.d.ts","names":[],"sources":["../../../src/loadDictionaries/loadRemoteDictionaries.ts"],"mappings":";;;;qBAYa,4BAAyB,eACrB,gBAAgB,kBAC9B;qBAOU,yBAAsB,0CAAA,gBAAA,kBAEf,QAAQ,+BAA6B;EAErD;EACA;EACA,WAAW,OAAO;MAEnB,QAAQ"}

package/dist/types/loadDictionaries/logTypeScriptErrors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logTypeScriptErrors.d.ts","names":[],"sources":["../../../src/loadDictionaries/logTypeScriptErrors.ts"],"mappings":";;;;;;qBAoQa,sBAAmB,qBACX,eACJ,mBACd"}
+{"version":3,"file":"logTypeScriptErrors.d.ts","names":[],"sources":["../../../src/loadDictionaries/logTypeScriptErrors.ts"],"mappings":";;;;;;qBAsRa,sBAAmB,qBACX,eACJ,mBACd"}

package/dist/types/loadDictionaries/remoteDictionaryClient.d.ts

@@ -0,0 +1,14 @@
+import { fetchDistantDictionaries } from "../fetchDistantDictionaries.js";
+import { IntlayerConfig } from "@intlayer/types/config";
+import { dictionaryEndpoint } from "@intlayer/api/dictionary";
+//#region src/loadDictionaries/remoteDictionaryClient.d.ts
+/**
+ * Creates the CMS dictionary client.
+ *
+ * Kept in its own module so `loadRemoteDictionaries` can import it lazily:
+ * `@intlayer/api` is only loaded when remote credentials are configured.
+ */
+export declare const createRemoteDictionaryClient: (configuration: IntlayerConfig) => ReturnType<typeof dictionaryEndpoint>;
+//#endregion
+export { fetchDistantDictionaries };
+//# sourceMappingURL=remoteDictionaryClient.d.ts.map

package/dist/types/loadDictionaries/remoteDictionaryClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteDictionaryClient.d.ts","names":[],"sources":["../../../src/loadDictionaries/remoteDictionaryClient.ts"],"mappings":";;;;;;;;;;qBAYa,+BAA4B,eACxB,mBACd,kBAAkB"}

package/dist/types/prepareIntlayerServer.d.ts

@@ -0,0 +1,67 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+//#region src/prepareIntlayerServer.d.ts
+/**
+ * Explicit override, for any setup the detection below does not recognise:
+ * `INTLAYER_WATCH=true` forces the content watcher on, `INTLAYER_WATCH=false`
+ * forces it off.
+ */
+export declare const INTLAYER_WATCH_ENV_VAR = "INTLAYER_WATCH";
+/**
+ * Whether a command line is a watcher that restarts its child on changes.
+ *
+ * @example
+ * ```ts
+ * getIsDevWatcherCommand('node /app/node_modules/.bin/nodemon src/index.ts'); // → true
+ * getIsDevWatcherCommand('node dist/index.js'); // → false
+ * ```
+ */
+export declare const getIsDevWatcherCommand: (command: string) => boolean;
+/**
+ * Whether a server process runs in development, and so should watch the
+ * content declarations.
+ *
+ * `INTLAYER_WATCH=true|false` decides first, then `NODE_ENV` when set. An unset
+ * `NODE_ENV` is not a sign of development (`bun dist/index.mjs` rarely sets
+ * it), so the process must then show a positive signal, cheapest first:
+ * 1. a runtime watch flag or marker (`bun --watch`/`--hot`, `node --watch`,
+ *    `ts-node-dev`);
+ * 2. a `dev`-like package script;
+ * 3. a restarting watcher in its own command line or its ancestors'
+ *    (`deno run --watch`, `nodemon`, `tsx watch`…), for those started
+ *    directly rather than through a script.
+ */
+export declare const getIsServerDevelopment: () => Promise<boolean>;
+export type PrepareIntlayerServerOptions = {
+  /**
+   * How the integration names itself in the watcher lock and in messages, e.g.
+   * `express-intlayer`.
+   */
+  label: string;
+  /**
+   * Whether to watch the content declarations after preparing them.
+   * Defaults to {@link getIsServerDevelopment}.
+   */
+  watch?: boolean;
+};
+/**
+ * Prepares the dictionaries for a server integration (Express, Fastify, Hono…)
+ * and, in development, keeps them in sync with the content declarations.
+ *
+ * Replaces wrapping the dev server in `intlayer watch --with`: the watcher runs
+ * inside the server, deduplicated through the project's watcher lock, so a
+ * server restarted by `tsx watch` / `node --watch` hands it over to its
+ * successor, and a remaining `intlayer watch` makes it stand down.
+ *
+ * Fire-and-forget: the server must not wait on the build to start listening.
+ *
+ * @param configuration - The resolved Intlayer configuration.
+ * @param options - How the integration identifies itself, and whether to watch.
+ *
+ * @example
+ * ```ts
+ * prepareIntlayerServer(getConfiguration(), { label: 'express-intlayer' });
+ * ```
+ */
+export declare const prepareIntlayerServer: (configuration: IntlayerConfig, { label, watch }: PrepareIntlayerServerOptions) => void;
+//#endregion
+//# sourceMappingURL=prepareIntlayerServer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepareIntlayerServer.d.ts","names":[],"sources":["../../src/prepareIntlayerServer.ts"],"mappings":";;;;;;;qBAWa;;;;;;;;;;qBAiDA,yBAAsB;;;;;;;;;;;;;;;qBA4BtB,8BAAmC;YAkCpC;;;;;EAKV;;;;;EAKA;;;;;;;;;;;;;;;;;;;;;qBAsBW,wBAAqB,eACjB,kBAAc,OAAA,SACX"}

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

@@ -1 +1 @@
-{"version":3,"file":"analyzeBundleContent.d.ts","names":[],"sources":["../../../src/scan/analyzeBundleContent.ts"],"mappings":";;;;;;;;;;;qBA6Ka,uBAAoB,QACvB,oBAAkB,qBACP,uBACE,0BAEpB"}
+{"version":3,"file":"analyzeBundleContent.d.ts","names":[],"sources":["../../../src/scan/analyzeBundleContent.ts"],"mappings":";;;;;;;;;;;qBAkNa,uBAAoB,QACvB,oBAAkB,qBACP,uBACE,0BAEpB"}

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

@@ -37,10 +37,13 @@ export declare const scoreRecord: {
   readonly url_htmlDir: 3;
   readonly url_hasCanonical: 10;
   readonly url_hreflang: 9;
+  readonly url_hreflangReciprocal: 8;
   readonly url_hasLocalizedLinks: 8;
   readonly url_hasXDefault: 7;
   readonly url_allAnchorsLocalized: 6;
-  readonly url_currentLocale: 3;
+  readonly url_hasLangSelector: 6;
+  readonly url_currentLocale: 5;
+  readonly url_ogLocale: 3;
   readonly url_unusedBundleContent: 8;
 };
 /** Identifier of a scorable check (without the URL suffix). */

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

@@ -1 +1 @@
-{"version":3,"file":"calculateScore.d.ts","names":[],"sources":["../../../src/scan/calculateScore.ts"],"mappings":";;;;;;;;;;YAUY;;EAEV;;EAEA;;;;;;;;;YAUU;EACV;EACA;;;qBAgBW;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;;YAIU,8BAA8B;;;;;;;;;;qBAW7B,cAAW,OAAW,OAAK,OAAS,kBAAgB;;;;;;;qBAyBpD,iBAAc,OAAW"}
+{"version":3,"file":"calculateScore.d.ts","names":[],"sources":["../../../src/scan/calculateScore.ts"],"mappings":";;;;;;;;;;YAUY;;EAEV;;EAEA;;;;;;;;;YAUU;EACV;EACA;;;qBAgBW;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;;YAIU,8BAA8B;;;;;;;;;;qBAW7B,cAAW,OAAW,OAAK,OAAS,kBAAgB;;;;;;;qBAyBpD,iBAAc,OAAW"}

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

@@ -1,36 +1,129 @@
+import { RoutingDetection } from "./detection/detectRoutingStrategy.js";
 import { BundleChunkInput, BundleContentAnalysis, ScanEvent } from "./types.js";
-import { Anchor } from "./parseHtml.js";
+import { ScanFetchOptions } from "./fetchText.js";
+import { Anchor, HreflangLink } from "./parseHtml.js";
 //#region src/scan/checks.d.ts
+/** Receives every check result as soon as it is produced. */
+export type EmitScanEvent = (event: ScanEvent) => void;
+/** Signals of the scanned page shared by the page-level checks. */
+export type PageSignals = {
+  targetUrl: string;
+  langTag?: string;
+  dirTag?: string;
+  ogLocale?: string;
+  /** `og:locale:alternate` values. */
+  ogLocaleAlternates?: string[];
+  /** Raw `href` of the canonical link (`''` when present but empty). */
+  canonicalHref?: string;
+  hreflangs: HreflangLink[];
+  anchors: Anchor[];
+  routing: RoutingDetection;
+  /** Locale of the page: from its URL when possible, else `<html lang>`. */
+  pageLocale?: string;
+};
 /** Format a byte count as a human-readable size. */
 export declare const formatSize: (bytes: number) => string;
+/** `url_htmlLang`: `<html lang>` is present and a valid BCP 47 tag. */
+export declare const checkHtmlLang: ({ targetUrl, langTag }: PageSignals, emit: EmitScanEvent) => void;
+/**
+ * `url_htmlDir`: the text direction matches the language. `dir` is only
+ * required for right-to-left languages, `ltr` being the browser default.
+ */
+export declare const checkHtmlDir: ({ targetUrl, langTag, dirTag }: PageSignals, emit: EmitScanEvent) => void;
+/**
+ * `url_currentLocale`: the locale announced by `<html lang>`, the URL and the
+ * self hreflang entry agree.
+ */
+export declare const checkLocaleConsistency: ({ targetUrl, langTag, hreflangs, routing }: PageSignals, emit: EmitScanEvent) => void;
+/**
+ * `url_ogLocale`: `og:locale` is set, uses the Open Graph `language_TERRITORY`
+ * format (`en_GB`, not `en` nor `en-GB`) and matches `<html lang>`.
+ * `og:locale:alternate` values must use the same format.
+ */
+export declare const checkOgLocale: ({ targetUrl, ogLocale, ogLocaleAlternates, langTag }: PageSignals, emit: EmitScanEvent) => void;
+/**
+ * `url_hasCanonical`: a canonical link exists and does not point to another
+ * locale version (which would de-index the current one).
+ */
+export declare const checkCanonical: ({ targetUrl, canonicalHref, hreflangs, routing, pageLocale }: PageSignals, emit: EmitScanEvent) => void;
+/**
+ * `url_hreflang`: hreflang tags exist, use valid codes and absolute URLs, have
+ * no duplicates, and include a self reference.
+ */
+export declare const checkHreflang: ({ targetUrl, hreflangs, canonicalHref }: PageSignals, emit: EmitScanEvent) => void;
+/** `url_hasXDefault`: an `x-default` hreflang is declared. */
+export declare const checkXDefault: ({ targetUrl, hreflangs }: PageSignals, emit: EmitScanEvent) => void;
+/**
+ * `url_hreflangReciprocal`: every alternate answers with a 200, is not
+ * redirected, links back to this page and declares the expected language.
+ * Search engines ignore hreflang pairs without a return link.
+ */
+export declare const checkHreflangReciprocity: ({ targetUrl, hreflangs, canonicalHref }: PageSignals, fetchOptions: ScanFetchOptions, emit: EmitScanEvent) => Promise<void>;
 /**
- * Check the `<html>` element attributes (`lang`, `dir`) and the resulting
- * current-locale signal. Returns the detected language tag.
+ * Link checks, interpreted through the detected routing strategy (so an
+ * unprefixed link is correct on the default locale of a `prefix-no-default`
+ * site, and `?lang=` links are understood on `search-params` sites):
+ *
+ * - `url_hasLocalizedLinks`: internal links keep the page locale
+ * - `url_allAnchorsLocalized`: no internal link loses or switches the locale
+ * - `url_hasLangSelector`: crawlable links to the other locale versions exist
  */
-export declare const checkHtmlAttributes: (html: string, targetUrl: string, events: ScanEvent[]) => {
-  langTag: string | undefined;
+export declare const checkInternalLinks: (signals: PageSignals, emit: EmitScanEvent) => void;
+/** Human-readable version of a {@link BundleContentAnalysis}, for display. */
+export declare const formatBundleAnalysis: (analysis: BundleContentAnalysis) => {
+  currentLocale: string;
+  totalPageSize: string;
+  renderedContentSize: string;
+  contentSize: string;
+  totalLocaleSize: string;
+  totalUnusedLocaleSize: string;
+  unusedPercentOfLocale: string;
+  mainBundleChunks: {
+    filename: string;
+    url: string;
+    fileSize: string;
+    totalLocaleSize: string;
+    usedLocaleSize: string;
+    unusedLocaleSize: string;
+    dictionariesFound: number;
+    unusedPercent: string;
+  }[];
+  lazyBundleChunks: {
+    filename: string;
+    url: string;
+    fileSize: string;
+    totalLocaleSize: string;
+    usedLocaleSize: string;
+    unusedLocaleSize: string;
+    dictionariesFound: number;
+    unusedPercent: string;
+  }[];
 };
-/** Check the presence of a canonical link. */
-export declare const checkCanonical: (html: string, targetUrl: string, events: ScanEvent[]) => void;
 /**
- * Check the page's hreflang structure and collect discovered locales into
- * `localesSet`.
+ * `url_unusedBundleContent`: share of other-locale translations shipped in the
+ * eagerly loaded bundles. Returns the raw analysis for reporting.
  */
-export declare const checkLinguisticStructure: (html: string, targetUrl: string, localesSet: Set<string>, events: ScanEvent[]) => void;
+export declare const checkBundleContent: (chunks: BundleChunkInput[], html: string, currentLocale: string | undefined, targetUrl: string, totalPageSize: number, emit: EmitScanEvent) => BundleContentAnalysis | undefined;
 /**
- * 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.
+ * Fetch `robots.txt` and check that neither the site nor its localized URLs
+ * are blocked for Googlebot.
+ *
+ * - `robots_robotsPresent`
+ * - `robots_noLocalizedUrlsForgotten`
+ *
+ * @param localizedUrls - URLs of every locale version (hreflang alternates).
+ * @returns The sitemaps declared in `robots.txt`.
  */
-export declare const checkUrlStructure: (anchors: Anchor[], origin: string, targetUrl: string, events: ScanEvent[]) => void;
+export declare const checkRobots: (origin: string, localizedUrls: string[], fetchOptions: ScanFetchOptions, emit: EmitScanEvent) => Promise<string[]>;
 /**
- * Analyze the JavaScript bundles for unused locale content and emit the
- * corresponding event. Returns the analysis so callers can report on it.
+ * Read the sitemaps (declared in `robots.txt`, else the default locations,
+ * following sitemap indexes) and check their locale coverage.
+ *
+ * - `sitemap_sitemapPresent`
+ * - `sitemap_noLocalizedUrlsForgotten`: every locale is listed, and entries
+ *   declaring alternates declare all of them
+ * - `sitemap_hasAlternates` / `sitemap_hasXDefault`
  */
-export 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. */
-export declare const checkRobots: (origin: string, discoveredLocales: Set<string>, userAgent: string, events: ScanEvent[]) => Promise<void>;
-/** Fetch and check `sitemap.xml`, emitting sitemap-related events. */
-export declare const checkSitemap: (origin: string, discoveredLocales: Set<string>, userAgent: string, events: ScanEvent[]) => Promise<void>;
+export declare const checkSitemap: (origin: string, declaredSitemapUrls: string[], routing: RoutingDetection, fetchOptions: ScanFetchOptions, emit: EmitScanEvent) => Promise<void>;
 //#endregion
 //# sourceMappingURL=checks.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"checks.d.ts","names":[],"sources":["../../../src/scan/checks.ts"],"mappings":";;;;qBAgBa,aAAU;;;;;qBAUV,sBAAmB,cAClB,mBACK,QACT;EACL;;;qBAmCQ,iBAAc,cACb,mBACK,QACT;;;;;qBAcG,2BAAwB,cACvB,mBACK,YACL,aAAW,QACf;;;;;;qBAwCG,oBAAiB,SACnB,UAAQ,gBACH,mBACG,QACT;;;;;qBAwEG,qBAAkB,QACrB,oBAAkB,cACd,mCACqB,mBAChB,uBACI,QACb,gBACP;;qBA0CU,cAAW,gBACR,mBACK,aAAW,mBACb,QACT,gBACP;;qBA0DU,eAAY,gBACT,mBACK,aAAW,mBACb,QACT,gBACP"}
+{"version":3,"file":"checks.d.ts","names":[],"sources":["../../../src/scan/checks.ts"],"mappings":";;;;;;YAkCY,iBAAiB,OAAO;;YAGxB;EACV;EACA;EACA;EACA;;EAEA;;EAEA;EACA,WAAW;EACX,SAAS;EACT,SAAS;;EAET;;;qBAWW,aAAU;;qBAgCV,kBAAa,WAAA,WACA,aAAW,MAC7B;;;;;qBAqBK,iBAAY,WAAA,SAAA,UACS,aAAW,MACrC;;;;;qBAuCK,2BAAsB,WAAA,SAAA,WAAA,WACW,aAAW,MACjD;;;;;;qBA4DK,kBAAa,WAAA,UAAA,oBAAA,WACmC,aAAW,MAChE;;;;;qBAmEK,mBAAc,WAAA,eAAA,WAAA,SAAA,cACqC,aAAW,MACnE;;;;;qBAgDK,kBAAa,WAAA,WAAA,iBACiB,aAAW,MAC9C;;qBAgFK,kBAAa,WAAA,aACE,aAAW,MAC/B;;;;;;qBA4EK,6BAAwB,WAAA,WAAA,iBACM,aAAW,cACtC,kBAAgB,MACxB,kBACL;;;;;;;;;;qBAkFU,qBAAkB,SACpB,aAAW,MACd;;qBAwFK,uBAAoB,UAAc;EAC7C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;EACA;;;;;;;;;;;;;;;qBAOW,qBAAkB,QACrB,oBAAkB,cACd,mCACqB,mBAChB,uBACI,MACf,kBACL;;;;;;;;;;;qBAoDU,cAAW,gBACR,yBACS,cACT,kBAAgB,MACxB,kBACL;;;;;;;;;;qBAwDU,eAAY,gBACT,+BACe,SACpB,kBAAgB,cACX,kBAAgB,MACxB,kBACL"}

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

@@ -0,0 +1,29 @@
+//#region src/scan/detection/checkDetails.d.ts
+/** Details of a scan check, split for display. */
+export type CheckDetailParts = {
+  /** Explanation of the check result. */
+  message?: string;
+  /** Offending `<a>` elements, as HTML source. */
+  links: string[];
+  /** Other listed items: issues, hreflang alternates, URLs… */
+  items: string[];
+};
+/**
+ * Split the details attached to a scan check into its message, the listed
+ * links (HTML source) and the other listed items. Shapes without any of them
+ * (bundle summaries, hreflang lists…) return empty lists.
+ *
+ * @param details - The `success` / `warning` / `error` payload of a check.
+ */
+export declare const splitCheckDetails: (details: unknown) => CheckDetailParts;
+/**
+ * Turn the details attached to a scan check into short printable lines: its
+ * message, then the listed issues / links / URLs. Shared by the CLI report and
+ * the Chrome extension popup.
+ *
+ * @param details - The `success` / `warning` / `error` payload of a check.
+ * @returns The message first, then one line per listed item.
+ */
+export declare const getCheckDetailLines: (details: unknown) => string[];
+//#endregion
+//# sourceMappingURL=checkDetails.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkDetails.d.ts","names":[],"sources":["../../../../src/scan/detection/checkDetails.ts"],"mappings":";;YACY;;EAEV;;EAEA;;EAEA;;;;;;;;;qBAUW,oBAAiB,qBAAuB;;;;;;;;;qBAkCxC,sBAAmB"}

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

@@ -0,0 +1,44 @@
+import { RoutingDetection } from "./detectRoutingStrategy.js";
+//#region src/scan/detection/classifyInternalLinks.d.ts
+/** A page anchor, as parsed from HTML or read from a live DOM. */
+export type LinkAnchor = {
+  href: string;
+  text: string;
+  /** `hreflang` attribute, set on language-switcher links. */
+  hreflang?: string;
+};
+/** Input of {@link classifyInternalLinks}. */
+export type LinkClassificationInput<Anchor extends LinkAnchor> = {
+  /** Absolute URL of the page holding the anchors. */
+  targetUrl: string;
+  anchors: Anchor[];
+  hreflangs: {
+    hreflang: string;
+    href: string;
+  }[];
+  routing: RoutingDetection;
+  /** Locale of the page. */
+  pageLocale?: string;
+};
+/** Internal anchors of a page, grouped by the locale they lead to. */
+export type LinkClassification<Anchor extends LinkAnchor> = {
+  /** Internal page links, language-switcher links excluded. */
+  internalLinks: Anchor[];
+  /** Internal links keeping the page locale. */
+  sameLocaleLinks: Anchor[];
+  /** Internal links leading to another locale. */
+  otherLocaleLinks: Anchor[];
+  /** Internal links whose URL carries no locale. */
+  unlocalizedLinks: Anchor[];
+  /** Links to the other locale versions (hreflang alternates). */
+  switcherLinks: Anchor[];
+};
+/**
+ * Group the internal anchors of a page by the locale they lead to, reading
+ * each URL through the detected routing strategy (so unprefixed links count as
+ * the default locale on a `prefix-no-default` site, and `?lang=` is understood
+ * on a `search-params` site).
+ */
+export declare const classifyInternalLinks: <Anchor extends LinkAnchor>({ targetUrl, anchors, hreflangs, routing, pageLocale }: LinkClassificationInput<Anchor>) => LinkClassification<Anchor>;
+//#endregion
+//# sourceMappingURL=classifyInternalLinks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"classifyInternalLinks.d.ts","names":[],"sources":["../../../../src/scan/detection/classifyInternalLinks.ts"],"mappings":";;;YAKY;EACV;EACA;;EAEA;;;YAIU,wBAAwB,eAAe;;EAEjD;EACA,SAAS;EACT;IAAa;IAAkB;;EAC/B,SAAS;;EAET;;;YAIU,mBAAmB,eAAe;;EAE5C,eAAe;;EAEf,iBAAiB;;EAEjB,kBAAkB;;EAElB,kBAAkB;;EAElB,eAAe;;;;;;;;qBAYJ,wBAAyB,eAAe,cAAU,WAAA,SAAA,WAAA,SAAA,cAM5D,wBAAwB,YAAU,mBAAmB"}

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

@@ -0,0 +1,60 @@
+//#region src/scan/detection/detectRoutingStrategy.d.ts
+/**
+ * How a website exposes its locales in URLs. Mirrors Intlayer's
+ * `routing.mode` values, plus the domain-based strategies.
+ *
+ * - `prefix-all`: every locale is prefixed (`/en/about`, `/fr/about`)
+ * - `prefix-no-default`: the default locale is not prefixed (`/about`, `/fr/about`)
+ * - `search-params`: the locale is a query parameter (`/about?lang=fr`)
+ * - `subdomain`: the locale is a subdomain (`fr.example.com`)
+ * - `domain`: one domain per locale (`example.fr`, `example.de`)
+ * - `no-prefix`: a single URL serves every locale (cookie / header based)
+ * - `unknown`: not enough signals to decide
+ */
+export type RoutingStrategy = 'prefix-all' | 'prefix-no-default' | 'search-params' | 'subdomain' | 'domain' | 'no-prefix' | 'unknown';
+/** Result of {@link detectRoutingStrategy}. */
+export type RoutingDetection = {
+  strategy: RoutingStrategy;
+  /**
+   * `high` when inferred from the hreflang alternates, `low` when guessed from
+   * the scanned URL alone.
+   */
+  confidence: 'high' | 'low';
+  /** Locales known to the site (hreflang values, else the page `lang`). */
+  locales: string[];
+  /** Locale served without any marker (`prefix-no-default`, `search-params`…). */
+  defaultLocale?: string;
+  /** Query parameter carrying the locale, for `search-params`. */
+  searchParamName?: string;
+  /** Hostname → locale map, for `subdomain` / `domain`. */
+  hostLocales?: Record<string, string>;
+  /** Locale of the scanned page according to its URL alone. */
+  urlLocale?: string;
+  /** Human-readable explanation of the decision. */
+  evidence: string;
+};
+/** Input of {@link detectRoutingStrategy}. */
+export type RoutingDetectionInput = {
+  /** Absolute URL of the scanned page. */
+  pageUrl: string;
+  /** Value of `<html lang>`, when present. */
+  htmlLang?: string;
+  /** `<link rel="alternate" hreflang>` entries of the page. */
+  hreflangs: {
+    hreflang: string;
+    href: string;
+  }[];
+};
+/** Locale of a URL according to an already-detected routing strategy. */
+export declare const getUrlLocale: (url: string, routing: RoutingDetection) => string | undefined;
+/**
+ * Detect how the site encodes the locale in its URLs (path prefix, query
+ * parameter, subdomain, domain or nothing).
+ *
+ * The hreflang alternates are the most reliable signal: each one pairs a
+ * locale with its URL, so the shared pattern reveals the strategy. Without
+ * alternates the scanned URL alone is used, with `confidence: 'low'`.
+ */
+export declare const detectRoutingStrategy: ({ pageUrl, htmlLang, hreflangs }: RoutingDetectionInput) => RoutingDetection;
+//#endregion
+//# sourceMappingURL=detectRoutingStrategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"detectRoutingStrategy.d.ts","names":[],"sources":["../../../../src/scan/detection/detectRoutingStrategy.ts"],"mappings":";;;;;;;;;;;;;YAoBY;;YAUA;EACV,UAAU;;;;;EAKV;;EAEA;;EAEA;;EAEA;;EAEA,cAAc;;EAEd;;EAEA;;;YAIU;;EAEV;;EAEA;;EAEA;IAAa;IAAkB;;;;qBAMpB,eAAY,aACZ,SACF;;;;;;;;;qBA+ME,0BAAqB,SAAA,UAAA,aAI/B,0BAAwB"}

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

@@ -0,0 +1,60 @@
+import { TechnologyCategory, TechnologySignature } from "./technologySignatures.js";
+//#region src/scan/detection/detectTechnologies.d.ts
+/** A technology detected on the scanned page. */
+export type DetectedTechnology = {
+  /** Stable identifier, e.g. `nextjs`, `crowdin`. */
+  id: string;
+  /** Human-readable name, e.g. `Next.js`. */
+  name: string;
+  category: TechnologyCategory;
+  /** Version when it can be read from the page, e.g. `14.2.3`. */
+  version?: string;
+  /** Short explanation of the signal that triggered the detection. */
+  evidence: string;
+};
+/**
+ * Raw signals collected from a page. Every field is optional so each consumer
+ * provides what it can: the CLI basic mode only has HTML + scripts, the
+ * backend and the extension also read window globals and storage keys.
+ */
+export type TechnologyDetectionInput = {
+  /**
+   * URL of the scanned page. Resource URLs on its own site are ignored for
+   * third-party services, so the Crowdin website is not reported as using
+   * Crowdin because it loads its own favicon.
+   */
+  pageUrl?: string;
+  /** HTML document, inline scripts included. */
+  html?: string;
+  /** Script / stylesheet / iframe / network request URLs. */
+  resourceUrls?: string[];
+  /** Contents of the same-origin JavaScript chunks. */
+  scripts?: string[];
+  /** Names of the window globals that exist on the page. */
+  globals?: string[];
+  /** Cookie / web-storage keys found on the page. */
+  storageKeys?: string[];
+  /** Live-DOM markers, see {@link TechnologySignature.domMarkers}. */
+  domMarkers?: string[];
+  /** Values read from {@link TechnologySignature.versionGlobal} paths. */
+  globalVersions?: Record<string, string>;
+};
+/**
+ * Every window global and version path referenced by the signatures. Live-page
+ * collectors (extension, puppeteer) read these and pass back the ones present.
+ */
+export declare const getTechnologyGlobalNames: () => {
+  globals: string[];
+  versionGlobals: string[];
+};
+/**
+ * Detect the frameworks, i18n libraries, TMS and translation proxies used by a
+ * page from the raw signals collected on it.
+ *
+ * @param input - The {@link TechnologyDetectionInput} signals.
+ * @param signatures - Fingerprints to test, defaults to {@link technologySignatures}.
+ * @returns Detected technologies, in signature order.
+ */
+export declare const detectTechnologies: (input: TechnologyDetectionInput, signatures?: readonly TechnologySignature[]) => DetectedTechnology[];
+//#endregion
+//# sourceMappingURL=detectTechnologies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"detectTechnologies.d.ts","names":[],"sources":["../../../../src/scan/detection/detectTechnologies.ts"],"mappings":";;;YAQY;;EAEV;;EAEA;EACA,UAAU;;EAEV;;EAEA;;;;;;;YAQU;;;;;;EAMV;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,iBAAiB;;;;;;qBAmGN;EACX;EACA;;;;;;;;;;qBAoBW,qBAAkB,OACtB,0BAAwB,sBACV,0BACpB"}

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

@@ -0,0 +1,9 @@
+import { RoutingDetection, RoutingDetectionInput, RoutingStrategy, detectRoutingStrategy, getUrlLocale } from "./detectRoutingStrategy.js";
+import { TechnologyCategory, TechnologySignature, technologySignatures } from "./technologySignatures.js";
+import { DetectedTechnology, TechnologyDetectionInput, detectTechnologies, getTechnologyGlobalNames } from "./detectTechnologies.js";
+import { CheckDetailParts, getCheckDetailLines, splitCheckDetails } from "./checkDetails.js";
+import { LinkAnchor, LinkClassification, LinkClassificationInput, classifyInternalLinks } from "./classifyInternalLinks.js";
+import { findMatchingLocale, getLanguageCode, isRightToLeftLocale, isSameLanguage, isSameLocale, isValidLocaleCode, isValidOpenGraphLocale, looksLikeLocaleCode, normalizeLocaleCode, toOpenGraphLocale } from "./localeCode.js";
+import { BaseLocalePageInput, LocalizedPage, getLocalizedPages, isBaseLocalePage } from "./localizedPages.js";
+import { getFirstPathSegment, getSiteDomain, isAbsoluteUrl, normalizeHostname, normalizeUrl, parseUrl } from "./url.js";
+export { BaseLocalePageInput, CheckDetailParts, DetectedTechnology, LinkAnchor, LinkClassification, LinkClassificationInput, LocalizedPage, RoutingDetection, RoutingDetectionInput, RoutingStrategy, TechnologyCategory, TechnologyDetectionInput, TechnologySignature, classifyInternalLinks, detectRoutingStrategy, detectTechnologies, findMatchingLocale, getCheckDetailLines, getFirstPathSegment, getLanguageCode, getLocalizedPages, getSiteDomain, getTechnologyGlobalNames, getUrlLocale, isAbsoluteUrl, isBaseLocalePage, isRightToLeftLocale, isSameLanguage, isSameLocale, isValidLocaleCode, isValidOpenGraphLocale, looksLikeLocaleCode, normalizeHostname, normalizeLocaleCode, normalizeUrl, parseUrl, splitCheckDetails, technologySignatures, toOpenGraphLocale };