@intlayer/engine 9.4.3 → 9.5.0

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

@@ -1,9 +1,9 @@
 import { Score } from "./calculateScore.js";
 //#region src/scan/types.d.ts
 /** Status of an individual scan check. */
-type ScanCheckStatus = 'success' | 'warning' | 'error';
+export type ScanCheckStatus = 'success' | 'warning' | 'error';
 /** Per-status human-readable details attached to a {@link ScanEvent}. */
-type ScanEventDetails = {
+export type ScanEventDetails = {
   success?: unknown;
   warning?: unknown;
   error?: unknown;
@@ -12,22 +12,22 @@ type ScanEventDetails = {
  * A single check produced while scanning a page. The `type` matches a key of
  * the score table (optionally suffixed with the URL for URL-scoped checks).
  */
-type ScanEvent = {
+export type ScanEvent = {
   type: string;
   status: ScanCheckStatus;
   details?: ScanEventDetails;
 };
 /** How the scan was performed. */
-type ScanMode = 'basic' | 'deep';
+export type ScanMode = 'basic' | 'deep';
 /** A single JavaScript chunk fetched while scanning. */
-type BundleChunkInput = {
+export type BundleChunkInput = {
   url: string;
   /** Whether the chunk is eagerly loaded on the initial page load. */
   isMainBundle: boolean;
   content: string;
 };
 /** Locale-weight analysis of a single bundle chunk. */
-type ChunkAnalysis = {
+export type ChunkAnalysis = {
   url: string;
   fileSize: number;
   totalLocaleSize: number;
@@ -38,7 +38,7 @@ type ChunkAnalysis = {
   unusedPercent: number;
 };
 /** Aggregated locale-weight analysis across every fetched chunk. */
-type BundleContentAnalysis = {
+export type BundleContentAnalysis = {
   currentLocale: string;
   totalPageSize: number;
   renderedContentSize: number;
@@ -54,7 +54,7 @@ type BundleContentAnalysis = {
   lazyBundleChunks: ChunkAnalysis[];
 };
 /** Options controlling how a website is scanned. */
-type ScanOptions = {
+export type ScanOptions = {
   /**
    * Attempt a deeper, render-based scan using a locally installed `puppeteer`.
    * When `puppeteer` is not installed, the scan transparently falls back to the
@@ -67,7 +67,7 @@ type ScanOptions = {
   userAgent?: string;
 };
 /** Result of scanning a single page. */
-type ScanResult = {
+export type ScanResult = {
   url: string;
   /** Whether the scan ran in `basic` or `deep` mode. */
   mode: ScanMode;
@@ -87,5 +87,4 @@ type ScanResult = {
   bundle?: BundleContentAnalysis;
 };
 //#endregion
-export { BundleChunkInput, BundleContentAnalysis, ChunkAnalysis, ScanCheckStatus, ScanEvent, ScanEventDetails, ScanMode, ScanOptions, ScanResult };
 //# sourceMappingURL=types.d.ts.map

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

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

package/dist/types/syncPluginKit/createFileAdapter.d.ts

@@ -9,8 +9,8 @@ import { FilePathPattern } from "@intlayer/types/filePathPattern";
  * - `inclusive`: keep every glob match without fabricating missing entries
  *   (read-only load plugins, whose patterns may contain free `**` globs).
  */
-type FileAdapterDiscovery = 'strict' | 'inclusive';
-type CreateFileAdapterOptions = {
+export type FileAdapterDiscovery = 'strict' | 'inclusive';
+export type CreateFileAdapterOptions = {
   /**
    * Location of the files, as a static string, a templated string
    * (e.g. `./messages/{{locale}}/{{key}}.json`) or a function building the
@@ -39,12 +39,11 @@ type CreateFileAdapterOptions = {
  * Handles glob discovery of the source pattern, key/locale extraction from
  * paths, base-directory resolution, and change-detected atomic writes.
  */
-declare const createFileAdapter: (options: CreateFileAdapterOptions) => ContentAdapter;
+export declare const createFileAdapter: (options: CreateFileAdapterOptions) => ContentAdapter;
 /**
  * Default `readEntry` implementation: plain utf-8 read followed by the given
  * parser. Returns `undefined` for missing or unreadable files.
  */
-declare const createFileReader: (parse: (raw: string) => SyncContent) => (absoluteFilePath: string) => Promise<SyncContent | undefined>;
+export declare const createFileReader: (parse: (raw: string) => SyncContent) => (absoluteFilePath: string) => Promise<SyncContent | undefined>;
 //#endregion
-export { CreateFileAdapterOptions, FileAdapterDiscovery, createFileAdapter, createFileReader };
 //# sourceMappingURL=createFileAdapter.d.ts.map

package/dist/types/syncPluginKit/createFileAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createFileAdapter.d.ts","names":[],"sources":["../../../src/syncPluginKit/createFileAdapter.ts"],"mappings":";;;;;;;;;;;KAyBY;KAEA;;;;;;EAMV,QAAQ;;;;EAKR,OAAO;;;;;;;EAQP,aACE,0BACA,SAAS,sBACN,QAAQ;;;;EAKb,YAAY;;;;;;;;cAYD,oBAAiB,SACnB,6BACR;;;;;cAwNU,mBAAgB,QAClB,gBAAgB,iBAAW,6BACF,QAAQ"}
+{"version":3,"file":"createFileAdapter.d.ts","names":[],"sources":["../../../src/syncPluginKit/createFileAdapter.ts"],"mappings":";;;;;;;;;;;YAyBY;YAEA;;;;;;EAMV,QAAQ;;;;EAKR,OAAO;;;;;;;EAQP,aACE,0BACA,SAAS,sBACN,QAAQ;;;;EAKb,YAAY;;;;;;;;qBAYD,oBAAiB,SACnB,6BACR;;;;;qBAwNU,mBAAgB,QAClB,gBAAgB,iBAAW,6BACF,QAAQ"}

package/dist/types/syncPluginKit/createSyncPlugin.d.ts

@@ -11,7 +11,6 @@ import { Plugin } from "@intlayer/types/plugin";
  * payload format. Write-back only processes dictionaries whose `location`
  * matches this plugin instance, so adapters never see foreign content.
  */
-declare const createSyncPlugin: (options: CreateSyncPluginOptions) => Plugin;
+export declare const createSyncPlugin: (options: CreateSyncPluginOptions) => Plugin;
 //#endregion
-export { createSyncPlugin };
 //# sourceMappingURL=createSyncPlugin.d.ts.map

package/dist/types/syncPluginKit/createSyncPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createSyncPlugin.d.ts","names":[],"sources":["../../../src/syncPluginKit/createSyncPlugin.ts"],"mappings":";;;;;;;;;;;;;cAuCa,mBAAgB,SAAa,4BAA0B"}
+{"version":3,"file":"createSyncPlugin.d.ts","names":[],"sources":["../../../src/syncPluginKit/createSyncPlugin.ts"],"mappings":";;;;;;;;;;;;;qBA4Ga,mBAAgB,SAAa,4BAA0B"}

package/dist/types/syncPluginKit/extractKeyAndLocaleFromPath.d.ts

@@ -10,10 +10,9 @@ import { Locale } from "@intlayer/types/allLocales";
  * Missing placeholders fall back to `'index'` for the key and to
  * `defaultLocale` for the locale.
  */
-declare const extractKeyAndLocaleFromPath: (filePath: string, maskPattern: string, locales: Locale[], defaultLocale: Locale) => {
+export declare const extractKeyAndLocaleFromPath: (filePath: string, maskPattern: string, locales: Locale[], defaultLocale: Locale) => {
   key: string;
   locale: Locale;
 } | null;
 //#endregion
-export { extractKeyAndLocaleFromPath };
 //# sourceMappingURL=extractKeyAndLocaleFromPath.d.ts.map

package/dist/types/syncPluginKit/extractKeyAndLocaleFromPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractKeyAndLocaleFromPath.d.ts","names":[],"sources":["../../../src/syncPluginKit/extractKeyAndLocaleFromPath.ts"],"mappings":";;;;;;;;;;;;cAea,8BAA2B,kBACtB,qBACG,SACV,UAAQ,eACF;EACZ;EAAa,QAAQ"}
+{"version":3,"file":"extractKeyAndLocaleFromPath.d.ts","names":[],"sources":["../../../src/syncPluginKit/extractKeyAndLocaleFromPath.ts"],"mappings":";;;;;;;;;;;;qBAea,8BAA2B,kBACtB,qBACG,SACV,UAAQ,eACF;EACZ;EAAa,QAAQ"}

package/dist/types/syncPluginKit/filePathPatternHelpers.d.ts

@@ -9,7 +9,6 @@ import { FilePathPatternContext } from "@intlayer/types/filePathPattern";
  * patterns never reference them, so this single cast keeps the partial
  * context in one audited place instead of scattering `as any` at call sites.
  */
-declare const buildFilePathPatternContext: (key: string, locale?: string) => FilePathPatternContext;
+export declare const buildFilePathPatternContext: (key: string, locale?: string) => FilePathPatternContext;
 //#endregion
-export { buildFilePathPatternContext };
 //# sourceMappingURL=filePathPatternHelpers.d.ts.map

package/dist/types/syncPluginKit/filePathPatternHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filePathPatternHelpers.d.ts","names":[],"sources":["../../../src/syncPluginKit/filePathPatternHelpers.ts"],"mappings":";;;;;;;;;;;cAWa,8BAA2B,aAC3B,oBAEV"}
+{"version":3,"file":"filePathPatternHelpers.d.ts","names":[],"sources":["../../../src/syncPluginKit/filePathPatternHelpers.ts"],"mappings":";;;;;;;;;;;qBAWa,8BAA2B,aAC3B,oBAEV"}

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

@@ -1,6 +1,6 @@
-import { ContentAdapter, ContentEntry, ContentTarget, CreateSyncPluginOptions, FormatCodec, SyncContent, SyncDirection, SyncPluginContext } from "./types.js";
+import { ContentAdapter, ContentEntry, ContentTarget, CreateSyncPluginOptions, FormatCodec, SplitKeysMode, SyncContent, SyncDirection, SyncPluginContext } from "./types.js";
 import { CreateFileAdapterOptions, FileAdapterDiscovery, createFileAdapter, createFileReader } from "./createFileAdapter.js";
 import { createSyncPlugin } from "./createSyncPlugin.js";
 import { extractKeyAndLocaleFromPath } from "./extractKeyAndLocaleFromPath.js";
 import { buildFilePathPatternContext } from "./filePathPatternHelpers.js";
-export { type ContentAdapter, type ContentEntry, type ContentTarget, type CreateFileAdapterOptions, type CreateSyncPluginOptions, type FileAdapterDiscovery, type FormatCodec, type SyncContent, type SyncDirection, type SyncPluginContext, buildFilePathPatternContext, createFileAdapter, createFileReader, createSyncPlugin, extractKeyAndLocaleFromPath };
+export { type ContentAdapter, type ContentEntry, type ContentTarget, type CreateFileAdapterOptions, type CreateSyncPluginOptions, type FileAdapterDiscovery, type FormatCodec, type SplitKeysMode, type SyncContent, type SyncDirection, type SyncPluginContext, buildFilePathPatternContext, createFileAdapter, createFileReader, createSyncPlugin, extractKeyAndLocaleFromPath };

package/dist/types/syncPluginKit/types.d.ts

@@ -5,17 +5,17 @@ import { Locale } from "@intlayer/types/allLocales";
 /**
  * Structured dictionary content handled by sync plugins.
  */
-type SyncContent = Record<string, unknown>;
+export type SyncContent = Record<string, unknown>;
 /**
  * Context handed to every {@link ContentAdapter} call.
  */
-type SyncPluginContext = {
+export type SyncPluginContext = {
   configuration: IntlayerConfig;
 };
 /**
  * One translatable resource discovered in the external system.
  */
-type ContentEntry = {
+export type ContentEntry = {
   /** Dictionary key the entry maps to. */
   key: string;
   /** Locale of the entry content. */
@@ -35,7 +35,7 @@ type ContentEntry = {
 /**
  * Identifies where content must be written back by a {@link ContentAdapter}.
  */
-type ContentTarget = {
+export type ContentTarget = {
   key: string;
   locale: Locale;
 };
@@ -45,7 +45,7 @@ type ContentTarget = {
  * CMS…). Format concerns belong to {@link FormatCodec}, orchestration to
  * `createSyncPlugin`.
  */
-type ContentAdapter = {
+export type ContentAdapter = {
   /**
    * Enumerate every entry available in the external system.
    */
@@ -84,13 +84,28 @@ type ContentAdapter = {
    * set it explicitly (e.g. the file adapter splits when the source pattern
    * has no `{{key}}` segment).
    */
-  detectSplitKeys?: () => Promise<boolean>;
+  detectSplitKeys?: () => Promise<SplitKeysMode>;
 };
+/**
+ * How an entry's keys map onto dictionaries.
+ *
+ * - `false`  — one dictionary holds the whole entry.
+ * - `true`   — each *top-level* key becomes its own dictionary. The
+ *              `next-intl` / `react-intl` namespace model, where a single
+ *              `messages/{locale}.json` groups namespaces by first-level key.
+ * - `'key-prefix'` — the entry is a *flat* map whose keys are dotted ids
+ *              (`'footer.github'`); each id's first dot-segment becomes a
+ *              dictionary and the remainder becomes the key inside it. The
+ *              single-catalog model of `lingui` and of i18next's default
+ *              `translation` namespace, where the namespace lives in the id
+ *              rather than in the file layout.
+ */
+export type SplitKeysMode = boolean | 'key-prefix';
 /**
  * Format layer of a sync plugin: how a raw string payload maps to structured
  * dictionary content and back (JSON, PO, XLIFF…).
  */
-type FormatCodec = {
+export type FormatCodec = {
   /**
    * Parse a raw payload into dictionary content.
    * May throw on malformed payloads — callers treat a throw as empty content.
@@ -108,11 +123,11 @@ type FormatCodec = {
  * - `pull`: only ingest external content as dictionaries (read-only).
  * - `both`: ingest and write the merged build output back to the source.
  */
-type SyncDirection = 'pull' | 'both';
+export type SyncDirection = 'pull' | 'both';
 /**
  * Options of `createSyncPlugin`.
  */
-type CreateSyncPluginOptions = {
+export type CreateSyncPluginOptions = {
   /** Plugin name reported to the Intlayer engine (e.g. `sync-json`). */
   name: string;
   /** Transport used to enumerate, read and write entries. */
@@ -136,12 +151,11 @@ type CreateSyncPluginOptions = {
   /** Content format of the dictionaries (e.g. `'icu'`, `'po'`). */
   format?: DictionaryFormat;
   /**
-   * Whether each top-level key of an entry becomes its own dictionary instead
-   * of a single dictionary holding the whole entry (the `next-intl` /
-   * `react-intl` namespace model). When omitted, falls back to
-   * {@link ContentAdapter.detectSplitKeys}, then to `false`.
+   * How the entry's keys map onto dictionaries — see {@link SplitKeysMode}.
+   * When omitted, falls back to {@link ContentAdapter.detectSplitKeys}, then
+   * to `false`.
    */
-  splitKeys?: boolean;
+  splitKeys?: SplitKeysMode;
   /**
    * Fixed locale applied to every generated dictionary, overriding the locale
    * discovered per entry.
@@ -149,5 +163,4 @@ type CreateSyncPluginOptions = {
   localeOverride?: Locale;
 };
 //#endregion
-export { ContentAdapter, ContentEntry, ContentTarget, CreateSyncPluginOptions, FormatCodec, SyncContent, SyncDirection, SyncPluginContext };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/syncPluginKit/types.ts"],"mappings":";;;;;;;KAOY,cAAc;;;;KAKd;EACV,eAAe;;;;;KAML;;EAEV;;EAEA,QAAQ;;;;;EAKR;;;;;;EAMA;;;;;KAMU;EACV;EACA,QAAQ;;;;;;;;KASE;;;;EAIV,OAAO,SAAS,sBAAsB,QAAQ;;;;;;EAO9C,OACE,OAAO,cACP,SAAS,sBACN,QAAQ;;;;;EAMb,QACE,QAAQ,eACR,SAAS,aACT,SAAS,sBACN;;;;;;;EAQL,cACE,QAAQ,eACR,SAAS,sBACN;;;;;;EAOL,kBAAkB,SAAS,sBAAsB;;;;;EAMjD,kBAAkB,SAAS,sBAAsB;;;;;;EAOjD,wBAAwB;;;;;;KAOd;;;;;EAKV,QAAQ,gBAAgB;;;;EAKxB,YAAY,SAAS,aAAa;IAAW,QAAQ;;;;;;;;KAQ3C;;;;KAKA;;EAEV;;EAGA,SAAS;;;;;EAMT,YAAY;;;;;;EAOZ;;;;;EAMA;;EAGA,SAAS;;;;;;;EAQT;;;;;EAMA,iBAAiB"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/syncPluginKit/types.ts"],"mappings":";;;;;;;YAOY,cAAc;;;;YAKd;EACV,eAAe;;;;;YAML;;EAEV;;EAEA,QAAQ;;;;;EAKR;;;;;;EAMA;;;;;YAMU;EACV;EACA,QAAQ;;;;;;;;YASE;;;;EAIV,OAAO,SAAS,sBAAsB,QAAQ;;;;;;EAO9C,OACE,OAAO,cACP,SAAS,sBACN,QAAQ;;;;;EAMb,QACE,QAAQ,eACR,SAAS,aACT,SAAS,sBACN;;;;;;;EAQL,cACE,QAAQ,eACR,SAAS,sBACN;;;;;;EAOL,kBAAkB,SAAS,sBAAsB;;;;;EAMjD,kBAAkB,SAAS,sBAAsB;;;;;;EAOjD,wBAAwB,QAAQ;;;;;;;;;;;;;;;;YAiBtB;;;;;YAMA;;;;;EAKV,QAAQ,gBAAgB;;;;EAKxB,YAAY,SAAS,aAAa;IAAW,QAAQ;;;;;;;;YAQ3C;;;;YAKA;;EAEV;;EAGA,SAAS;;;;;EAMT,YAAY;;;;;;EAOZ;;;;;EAMA;;EAGA,SAAS;;;;;;EAOT,YAAY;;;;;EAMZ,iBAAiB"}

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

@@ -7,7 +7,6 @@ type AutoTransformationOptions = {
 /**
  * Automatically decorate content strings with md() or insert() if they match
  */
-declare const autoDecorateContent: (content: any, options?: boolean | AutoTransformationOptions) => any;
+export declare const autoDecorateContent: (content: any, options?: boolean | AutoTransformationOptions) => any;
 //#endregion
-export { autoDecorateContent };
 //# sourceMappingURL=autoDecorateContent.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"autoDecorateContent.d.ts","names":[],"sources":["../../../src/utils/autoDecorateContent.ts"],"mappings":";KAwEK;EACH;EACA;EACA;;;;;cAMW,sBAAmB,cAClB,oBACO"}
+{"version":3,"file":"autoDecorateContent.d.ts","names":[],"sources":["../../../src/utils/autoDecorateContent.ts"],"mappings":";KAwEK;EACH;EACA;EACA;;;;;qBAMW,sBAAmB,cAClB,oBACO"}

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

@@ -1,9 +1,9 @@
 import { RecastParser } from "@intlayer/babel/babelParser";
 //#region src/utils/babelParser.d.ts
 /** Drop-in replacement for `recast/parsers/typescript` (TS without JSX). */
-declare const typescriptParser: RecastParser;
+export declare const typescriptParser: RecastParser;
 /** Drop-in replacement for `recast/parsers/babel-ts` (TS *and* JSX). */
-declare const babelTsParser: RecastParser;
+export declare const babelTsParser: RecastParser;
 //#endregion
-export { type RecastParser, babelTsParser, typescriptParser };
+export type { RecastParser };
 //# sourceMappingURL=babelParser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"babelParser.d.ts","names":[],"sources":["../../../src/utils/babelParser.ts"],"mappings":";;;cA6Da,kBAAkB;;cAKlB,eAAe"}
+{"version":3,"file":"babelParser.d.ts","names":[],"sources":["../../../src/utils/babelParser.ts"],"mappings":";;;qBA6Da,kBAAkB;;qBAKlB,eAAe"}

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

@@ -21,7 +21,6 @@ import { IntlayerConfig } from "@intlayer/types/config";
  * // intlayer.config.ts: { content: { codeDir: ['node_modules/my-ds/src'] } }
  * const files = buildComponentFilesList(config);
  */
-declare const buildComponentFilesList: (config: IntlayerConfig, excludePattern?: string[]) => string[];
+export declare const buildComponentFilesList: (config: IntlayerConfig, excludePattern?: string[]) => string[];
 //#endregion
-export { buildComponentFilesList };
 //# sourceMappingURL=buildComponentFilesList.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"buildComponentFilesList.d.ts","names":[],"sources":["../../../src/utils/buildComponentFilesList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cAqEa,0BAAuB,QAC1B,gBAAc"}
+{"version":3,"file":"buildComponentFilesList.d.ts","names":[],"sources":["../../../src/utils/buildComponentFilesList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBAqEa,0BAAuB,QAC1B,gBAAc"}

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

@@ -3,7 +3,7 @@ import { IntlayerConfig } from "@intlayer/types/config";
 /**
  * Options for building the files list
  */
-type BuildComponentFilesListOptions = {
+export type BuildComponentFilesListOptions = {
   /**
    * Glob patterns to match files
    */
@@ -46,7 +46,7 @@ type BuildComponentFilesListOptions = {
  *   dot: true,
  * });
  */
-declare const buildComponentFilesList: (config: BuildComponentFilesListOptions) => string[];
+export declare const buildComponentFilesList: (config: BuildComponentFilesListOptions) => string[];
 /**
  * Convenience wrapper that derives all file-list options directly from an
  * `IntlayerConfig` object.
@@ -55,7 +55,6 @@ declare const buildComponentFilesList: (config: BuildComponentFilesListOptions)
  * content declaration file extensions and any `compiler.excludePattern`
  * entries defined in the configuration, and includes dot files.
  */
-declare const buildComponentFilesListFromConfig: (intlayerConfig: IntlayerConfig) => string[];
+export declare const buildComponentFilesListFromConfig: (intlayerConfig: IntlayerConfig) => string[];
 //#endregion
-export { BuildComponentFilesListOptions, buildComponentFilesList, buildComponentFilesListFromConfig };
 //# sourceMappingURL=buildFilesList.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"buildFilesList.d.ts","names":[],"sources":["../../../src/utils/buildFilesList.ts"],"mappings":";;;;;KAOY;;;;EAIV;;;;EAIA;;;;;;EAMA;;;;EAIA;;;;;;;;;;;;;;;;;;;;;;;;;cAmDW,0BAAuB,QAC1B;;;;;;;;;cAqDG,oCAAiC,gBAC5B"}
+{"version":3,"file":"buildFilesList.d.ts","names":[],"sources":["../../../src/utils/buildFilesList.ts"],"mappings":";;;;;YAOY;;;;EAIV;;;;EAIA;;;;;;EAMA;;;;EAIA;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDW,0BAAuB,QAC1B;;;;;;;;;qBAqDG,oCAAiC,gBAC5B"}

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

@@ -10,7 +10,6 @@
  * chunkArray(['a', 'b', 'c', 'd', 'e'], 2); // [['a', 'b'], ['c', 'd'], ['e']]
  * ```
  */
-declare const chunkArray: <T>(items: T[], chunkSize: number) => T[][];
+export declare const chunkArray: <T>(items: T[], chunkSize: number) => T[][];
 //#endregion
-export { chunkArray };
 //# sourceMappingURL=chunkArray.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"chunkArray.d.ts","names":[],"sources":["../../../src/utils/chunkArray.ts"],"mappings":";;;;;;;;;;;;cAWa,aAAc,GAAC,OAAS,KAAG,sBAAsB"}
+{"version":3,"file":"chunkArray.d.ts","names":[],"sources":["../../../src/utils/chunkArray.ts"],"mappings":";;;;;;;;;;;;qBAWa,aAAc,GAAC,OAAS,KAAG,sBAAsB"}

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

@@ -8,7 +8,7 @@
  */
 type JSONPrimitive = string | number | boolean | null;
 type JSONValue = JSONPrimitive | JSONObject | JSONArray;
-type JSONObject = {
+export type JSONObject = {
   [k: string]: JSONValue;
 };
 type JSONArray = JSONValue[];
@@ -27,7 +27,7 @@ type StrAppendPatch = {
 };
 type Patch = SetPatch | StrAppendPatch;
 type RootType = 'object' | 'array';
-type JsonChunk = {
+export type JsonChunk = {
   schemaVersion: 1;
   index: number;
   total: number;
@@ -38,7 +38,7 @@ type JsonChunk = {
 /**
  * Split JSON into chunks constrained by character count of serialized chunk.
  */
-declare const chunkJSON: (value: JSONObject | JSONArray, maxChars: number) => JsonChunk[];
+export declare const chunkJSON: (value: JSONObject | JSONArray, maxChars: number) => JsonChunk[];
 /**
  * Reassemble JSON from chunks.
  * - Validates checksums and indices.
@@ -49,8 +49,7 @@ declare const chunkJSON: (value: JSONObject | JSONArray, maxChars: number) => Js
  * Useful for processing individual chunks in a pipeline where you don't have all chunks yet.
  * Note: This will only reconstruct the partial content contained in this chunk.
  */
-declare const reconstructFromSingleChunk: (chunk: JsonChunk) => JSONObject | JSONArray;
-declare const assembleJSON: (chunks: JsonChunk[]) => JSONObject | JSONArray;
+export declare const reconstructFromSingleChunk: (chunk: JsonChunk) => JSONObject | JSONArray;
+export declare const assembleJSON: (chunks: JsonChunk[]) => JSONObject | JSONArray;
 //#endregion
-export { JSONObject, JsonChunk, assembleJSON, chunkJSON, reconstructFromSingleChunk };
 //# sourceMappingURL=chunkJSON.d.ts.map

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

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

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

@@ -0,0 +1,113 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+//#region src/utils/contentWatcherLock.d.ts
+/**
+ * What kind of process is watching the content declarations.
+ *
+ * - `cli` — the `intlayer watch` / `intlayer build --watch` command.
+ * - `bundler` — an Intlayer bundler plugin (e.g. `withIntlayer` on Next.js).
+ */
+export type ContentWatcherSource = 'cli' | 'bundler';
+export type ContentWatcherOwner = {
+  /** PID of the process holding the watcher. */
+  pid: number;
+  source: ContentWatcherSource;
+  /**
+   * How the owner should be named in a message, e.g. `intlayer watch` or
+   * `next-intlayer`.
+   */
+  label: string;
+  /**
+   * Release from which a `bundler` owner watches the content declarations on
+   * its own, so a CLI watcher finding it can name the version that made the
+   * parallel command redundant without keeping a table of its own.
+   */
+  since?: string;
+};
+/**
+ * Set on every process spawned by `intlayer watch --with` (and
+ * `intlayer build --watch --with`), so a bundler plugin running as that child
+ * knows a CLI watcher is already covering the project — without having to
+ * depend on the two processes reaching the lock file in a given order.
+ *
+ * Holds the label of the command that set it.
+ */
+export declare const CLI_CONTENT_WATCHER_ENV_VAR = "INTLAYER_CLI_CONTENT_WATCHER";
+/**
+ * Path of the lock coordinating every content watcher of one project.
+ *
+ * Deliberately at the root of `.intlayer` rather than in its `cache`
+ * subdirectory: `cleanOutputDir` wipes every subdirectory of `.intlayer`, so a
+ * lock kept in `cache` would be erased by any `prepareIntlayer` that cleans —
+ * after which a bundler plugin would see no owner and start a second watcher
+ * next to the `intlayer watch` still running. The root itself is never removed.
+ *
+ * @param configuration - The resolved Intlayer configuration.
+ */
+export declare const getContentWatcherLockFilePath: (configuration: IntlayerConfig) => string;
+/**
+ * Reads the lock, removing it when it describes a process that has since died.
+ *
+ * An unreadable or malformed lock is treated as abandoned: a corrupted file
+ * must never block the watcher for a whole dev session.
+ *
+ * @returns The live owner, or `null` when nothing is watching.
+ */
+export declare const getContentWatcherOwner: (configuration: IntlayerConfig) => Promise<ContentWatcherOwner | null>;
+/**
+ * Tries to become the process that watches this project's content
+ * declarations.
+ *
+ * Creating the file with `wx` is atomic, so exactly one process wins even when
+ * several try at the same moment — which is the normal case on Next.js, where
+ * `next.config.*` is evaluated in more than one process.
+ *
+ * @param configuration - The resolved Intlayer configuration.
+ * @param owner - How this process should describe itself to the others.
+ * @returns `true` when this process now owns the watcher.
+ */
+export declare const acquireContentWatcherLock: (configuration: IntlayerConfig, owner: Omit<ContentWatcherOwner, 'pid'>) => Promise<boolean>;
+/**
+ * The CLI watcher command this process was spawned by, or `null` when it was
+ * not started through `intlayer watch --with`.
+ */
+export declare const getCliContentWatcherLabel: () => string | null;
+/**
+ * Registers a CLI command as the content watcher of this project.
+ *
+ * Call it *before* spawning a `--with` child: taking the lock first means the
+ * bundler plugin inside that child never races the command for it, and the
+ * environment marker makes the child's decision independent of the filesystem
+ * altogether.
+ *
+ * @param configuration - The resolved Intlayer configuration.
+ * @param label - How the command should be named in a message.
+ * @returns The bundler already watching this project, or `null` when the
+ * command took the watcher for itself. A CLI watcher never stands down on that
+ * answer — watching is what it was asked to do — but reporting it lets the user
+ * know the parallel command has become redundant.
+ */
+export declare const claimCliContentWatcher: (configuration: IntlayerConfig, label: string) => Promise<ContentWatcherOwner | null>;
+type RedundantWatcherReport = {
+  /** Name of the CLI command watching, e.g. `intlayer watch`. */
+  cliLabel: string;
+  /** Name of the bundler integration watching, e.g. `next-intlayer`. */
+  bundlerLabel: string;
+  /**
+   * Release from which the bundler integration watches on its own. Omitted when
+   * the integration did not report one.
+   */
+  since?: string;
+};
+/**
+ * Reports a CLI watcher running alongside a bundler integration that watches
+ * on its own, and points at the parallel command as the part to drop.
+ *
+ * Emitted at most once per process: a bundler config is evaluated several times
+ * per command, and callers may re-enter this on a retry loop.
+ *
+ * @param configuration - The resolved Intlayer configuration.
+ * @param report - Who is watching, and from which release it became redundant.
+ */
+export declare const reportRedundantContentWatcher: (configuration: IntlayerConfig, { cliLabel, bundlerLabel, since }: RedundantWatcherReport) => void;
+//#endregion
+//# sourceMappingURL=contentWatcherLock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contentWatcherLock.d.ts","names":[],"sources":["../../../src/utils/contentWatcherLock.ts"],"mappings":";;;;;;;;YAaY;YAEA;;EAEV;EACA,QAAQ;;;;;EAKR;;;;;;EAMA;;;;;;;;;;qBAWW;;;;;;;;;;;;qBAkCA,gCAA6B,eACzB;;;;;;;;;qBA2BJ,yBAAsB,eAClB,mBACd,QAAQ;;;;;;;;;;;;;qBAuCE,4BAAyB,eACrB,gBAAc,OACtB,KAAK,gCACX;;;;;qBAkCU;;;;;;;;;;;;;;;;qBAkBA,yBAAsB,eAClB,gBAAc,kBAE5B,QAAQ;KAoBN;;EAEH;;EAEA;;;;;EAKA;;;;;;;;;;;;qBAaW,gCAA6B,eACzB,kBAAc,UAAA,cAAA,SACM"}

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

@@ -1,8 +1,7 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { ANSIColorsType } from "@intlayer/config/logger";
 //#region src/utils/formatter.d.ts
-declare const formatPath: (path: string | string[], color?: ANSIColorsType | false) => string;
-declare const formatLocale: (locale: LocalesValues | LocalesValues[], color?: ANSIColorsType | false) => string;
+export declare const formatPath: (path: string | string[], color?: ANSIColorsType | false) => string;
+export declare const formatLocale: (locale: LocalesValues | LocalesValues[], color?: ANSIColorsType | false) => string;
 //#endregion
-export { formatLocale, formatPath };
 //# sourceMappingURL=formatter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"formatter.d.ts","names":[],"sources":["../../../src/utils/formatter.ts"],"mappings":";;;cAYa,aAAU,yBACE,QACf;cAYG,eAAY,QACf,gBAAgB,iBAAe,QAChC"}
+{"version":3,"file":"formatter.d.ts","names":[],"sources":["../../../src/utils/formatter.ts"],"mappings":";;;qBAYa,aAAU,yBACE,QACf;qBAYG,eAAY,QACf,gBAAgB,iBAAe,QAChC"}

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

@@ -5,7 +5,6 @@ type TrunkOptions = {
   charStart?: number;
   charLength?: number;
 };
-declare const getChunk: (text: string, options?: TrunkOptions) => string;
+export declare const getChunk: (text: string, options?: TrunkOptions) => string;
 //#endregion
-export { getChunk };
 //# sourceMappingURL=getChunk.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getChunk.d.ts","names":[],"sources":["../../../src/utils/getChunk.ts"],"mappings":";KAEK;EACH;EACA;EACA;EACA;;cAGW,WAAQ,cAAgB,UAAW"}
+{"version":3,"file":"getChunk.d.ts","names":[],"sources":["../../../src/utils/getChunk.ts"],"mappings":";KAEK;EACH;EACA;EACA;EACA;;qBAGW,WAAQ,cAAgB,UAAW"}

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

@@ -8,7 +8,6 @@ import { IntlayerConfig } from "@intlayer/types/config";
  * format 'ts' -> '.content.ts'
  * format 'esm' -> '.content.js' (if matching .content.js is found in config)
  */
-declare const getContentExtension: (format: 'ts' | 'esm' | 'cjs' | 'json' | 'jsonc' | 'json5' | (string & {}), configuration: IntlayerConfig) => string;
+export declare const getContentExtension: (format: 'ts' | 'esm' | 'cjs' | 'json' | 'jsonc' | 'json5' | (string & {}), configuration: IntlayerConfig) => string;
 //#endregion
-export { getContentExtension };
 //# sourceMappingURL=getContentExtension.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getContentExtension.d.ts","names":[],"sources":["../../../src/utils/getContentExtension.ts"],"mappings":";;;;;;;;;;cAUa,sBAAmB,2EAC2C,eAC1D"}
+{"version":3,"file":"getContentExtension.d.ts","names":[],"sources":["../../../src/utils/getContentExtension.ts"],"mappings":";;;;;;;;;;qBAUa,sBAAmB,2EAC2C,eAC1D"}

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

@@ -1,8 +1,7 @@
 //#region src/utils/getFormatFromExtension.d.ts
-type Format = 'ts' | 'cjs' | 'esm' | 'json' | 'jsonc' | 'json5' | 'md' | 'yaml';
-type Extension = '.ts' | '.tsx' | '.js' | '.jsx' | '.cjs' | '.cjsx' | '.mjs' | '.mjsx' | '.json' | '.jsonc' | '.json5' | '.md' | '.mdx' | '.yaml' | '.yml';
-declare const getFormatFromExtension: (extension: Extension | (string & {})) => Format;
-declare const getExtensionFromFormat: (format: Format | (string & {})) => Extension;
+export type Format = 'ts' | 'cjs' | 'esm' | 'json' | 'jsonc' | 'json5' | 'md' | 'yaml';
+export type Extension = '.ts' | '.tsx' | '.js' | '.jsx' | '.cjs' | '.cjsx' | '.mjs' | '.mjsx' | '.json' | '.jsonc' | '.json5' | '.md' | '.mdx' | '.yaml' | '.yml';
+export declare const getFormatFromExtension: (extension: Extension | (string & {})) => Format;
+export declare const getExtensionFromFormat: (format: Format | (string & {})) => Extension;
 //#endregion
-export { Extension, Format, getExtensionFromFormat, getFormatFromExtension };
 //# sourceMappingURL=getFormatFromExtension.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getFormatFromExtension.d.ts","names":[],"sources":["../../../src/utils/getFormatFromExtension.ts"],"mappings":";KAAY;KAUA;cAiBC,yBAAsB,WACtB,8BACV;cA4BU,yBAAsB,QACzB,2BACP"}
+{"version":3,"file":"getFormatFromExtension.d.ts","names":[],"sources":["../../../src/utils/getFormatFromExtension.ts"],"mappings":";YAAY;YAUA;qBAiBC,yBAAsB,WACtB,8BACV;qBA4BU,yBAAsB,QACzB,2BACP"}

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

@@ -2,7 +2,6 @@
 /**
  * Fast hashing using cyrb53 algorithm for small unique strings with low collisions risk
  */
-declare const getPathHash: (filePath: string) => string;
+export declare const getPathHash: (filePath: string) => string;
 //#endregion
-export { getPathHash };
 //# sourceMappingURL=getPathHash.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getPathHash.d.ts","names":[],"sources":["../../../src/utils/getPathHash.ts"],"mappings":";;;;cAGa,cAAW"}
+{"version":3,"file":"getPathHash.d.ts","names":[],"sources":["../../../src/utils/getPathHash.ts"],"mappings":";;;;qBAGa,cAAW"}