@intlayer/engine 9.4.3 → 9.5.0

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

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

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

@@ -1,5 +1,4 @@
 //#region src/utils/mergeChunks.d.ts
-declare const mergeChunks: (chunks: any[]) => any;
+export declare const mergeChunks: (chunks: any[]) => any;
 //#endregion
-export { mergeChunks };
 //# sourceMappingURL=mergeChunks.d.ts.map

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

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

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

@@ -1,5 +1,5 @@
 //#region src/utils/pLimit.d.ts
-declare class Queue<T> {
+export declare class Queue<T> {
   #private;
   constructor();
   enqueue(value: T): void;
@@ -10,7 +10,6 @@ declare class Queue<T> {
   [Symbol.iterator](): Generator<T, void, unknown>;
   drain(): Generator<T | undefined, void, unknown>;
 }
-declare const pLimit: (concurrency: number) => (fn: (...args: any[]) => Promise<any>, ...arguments_: any[]) => Promise<any>;
+export declare const pLimit: (concurrency: number) => (fn: (...args: any[]) => Promise<any>, ...arguments_: any[]) => Promise<any>;
 //#endregion
-export { Queue, pLimit };
 //# sourceMappingURL=pLimit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pLimit.d.ts","names":[],"sources":["../../../src/utils/pLimit.ts"],"mappings":";cAca,MAAM;;EAKjB;EAIA,QAAQ,OAAO;EAcf,WAAW;EAWX,QAAQ;EAWR;MAMI;GAIF,OAAO,aAAa,UAAU;EAS/B,SAAS,UAAU;;cAOT,SAAM,yBAAuB,QAkE9B,gBAAgB,iBAAY,sBAEnC"}
+{"version":3,"file":"pLimit.d.ts","names":[],"sources":["../../../src/utils/pLimit.ts"],"mappings":";qBAca,MAAM;;EAKjB;EAIA,QAAQ,OAAO;EAcf,WAAW;EAWX,QAAQ;EAWR;MAMI;GAIF,OAAO,aAAa,UAAU;EAS/B,SAAS,UAAU;;qBAOT,SAAM,yBAAuB,QAkE9B,gBAAgB,iBAAY,sBAEnC"}

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

@@ -1,5 +1,4 @@
 //#region src/utils/parallelize.d.ts
-declare const parallelize: <T, R>(items: T[], callback?: (item: T) => Promise<R>, parallelLimit?: number) => Promise<R[]>;
+export declare const parallelize: <T, R>(items: T[], callback?: (item: T) => Promise<R>, parallelLimit?: number) => Promise<R[]>;
 //#endregion
-export { parallelize };
 //# sourceMappingURL=parallelize.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parallelize.d.ts","names":[],"sources":["../../../src/utils/parallelize.ts"],"mappings":";cAEa,cAAqB,GAAG,GAAC,OAC7B,KAAG,YACC,MAAM,MAAM,QAAQ,IAAE,2BAGhC,QAAQ"}
+{"version":3,"file":"parallelize.d.ts","names":[],"sources":["../../../src/utils/parallelize.ts"],"mappings":";qBAEa,cAAqB,GAAG,GAAC,OAC7B,KAAG,YACC,MAAM,MAAM,QAAQ,IAAE,2BAGhC,QAAQ"}

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

@@ -1,10 +1,10 @@
 import { pLimit } from "./pLimit.js";
 //#region src/utils/parallelizeGlobal.d.ts
 /** Get (and optionally configure) the single, shared limiter. */
-declare const getGlobalLimiter: (concurrency?: number) => (fn: (...args: any[]) => Promise<any>, ...arguments_: any[]) => Promise<any>;
+export declare const getGlobalLimiter: (concurrency?: number) => (fn: (...args: any[]) => Promise<any>, ...arguments_: any[]) => Promise<any>;
 /** Limits how many *tasks* run concurrently (independent from AI calls). */
-declare const getTaskLimiter: (concurrency?: number) => (fn: (...args: any[]) => Promise<any>, ...arguments_: any[]) => Promise<any>;
-declare const parallelizeGlobal: <T, R>(items: T[], callback?: (item: T, index: number) => Promise<R>, options?: {
+export declare const getTaskLimiter: (concurrency?: number) => (fn: (...args: any[]) => Promise<any>, ...arguments_: any[]) => Promise<any>;
+export declare const parallelizeGlobal: <T, R>(items: T[], callback?: (item: T, index: number) => Promise<R>, options?: {
   /** Share a single limiter across the app. If omitted, uses global limiter. */
   limiter?: ReturnType<typeof pLimit>;
   /** If provided and no limiter is passed, configure the global limiter. */
@@ -17,5 +17,4 @@ declare const parallelizeGlobal: <T, R>(items: T[], callback?: (item: T, index:
   wrapInLimiter?: boolean;
 }) => Promise<R[]>;
 //#endregion
-export { getGlobalLimiter, getTaskLimiter, parallelizeGlobal };
 //# sourceMappingURL=parallelizeGlobal.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parallelizeGlobal.d.ts","names":[],"sources":["../../../src/utils/parallelizeGlobal.ts"],"mappings":";;;cAQa,mBAAgB,0BAAwB,QAAA,gBAAA,iBAAA,sBAAA;;cAaxC,iBAAc,0BAAwB,QAAA,gBAAA,iBAAA,sBAAA;cAUtC,oBAA2B,GAAG,GAAC,OACnC,KAAG,YACC,MAAM,GAAG,kBAAkB,QAAQ,IAAE;;EAI9C,UAAU,kBAAkB;;EAE5B;;;;;;EAMA;MAED,QAAQ"}
+{"version":3,"file":"parallelizeGlobal.d.ts","names":[],"sources":["../../../src/utils/parallelizeGlobal.ts"],"mappings":";;;qBAQa,mBAAgB,0BAAwB,QAAA,gBAAA,iBAAA,sBAAA;;qBAaxC,iBAAc,0BAAwB,QAAA,gBAAA,iBAAA,sBAAA;qBAUtC,oBAA2B,GAAG,GAAC,OACnC,KAAG,YACC,MAAM,GAAG,kBAAkB,QAAQ,IAAE;;EAI9C,UAAU,kBAAkB;;EAE5B;;;;;;EAMA;MAED,QAAQ"}

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

@@ -0,0 +1,23 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+//#region src/utils/parseContentDeclarationFileName.d.ts
+export type ContentDeclarationFileName = {
+  /** Dictionary key derived from the file name, locale suffix excluded */
+  key: string;
+  /** Locale declared as a file name suffix, e.g. `about.fr.content.md` -> `fr` */
+  locale?: LocalesValues;
+};
+/**
+ * Splits a content declaration file name into its dictionary key and its
+ * optional locale suffix.
+ *
+ * @example
+ * parseContentDeclarationFileName('src/about.content.ts', configuration)
+ * // { key: 'about' }
+ *
+ * parseContentDeclarationFileName('src/about.fr.content.md', configuration)
+ * // { key: 'about', locale: 'fr' }
+ */
+export declare const parseContentDeclarationFileName: (filePath: string, configuration: IntlayerConfig) => ContentDeclarationFileName;
+//#endregion
+//# sourceMappingURL=parseContentDeclarationFileName.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parseContentDeclarationFileName.d.ts","names":[],"sources":["../../../src/utils/parseContentDeclarationFileName.ts"],"mappings":";;;YAIY;;EAEV;;EAEA,SAAS;;;;;;;;;;;;;qBAiBE,kCAA+B,kBAC1B,eACD,mBACd"}

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

@@ -3,7 +3,6 @@
  * Reads all JSON dictionary files from a directory, keyed by filename.
  * Uses readFileSync instead of require() to avoid require.cache memory leak.
  */
-declare const readDictionariesFromDisk: <T = Record<string, any>>(directory: string) => T;
+export declare const readDictionariesFromDisk: <T = Record<string, any>>(directory: string) => T;
 //#endregion
-export { readDictionariesFromDisk };
 //# sourceMappingURL=readDictionariesFromDisk.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"readDictionariesFromDisk.d.ts","names":[],"sources":["../../../src/utils/readDictionariesFromDisk.ts"],"mappings":";;;;;cAOa,2BAA4B,IAAI,qBAAmB,sBAE7D"}
+{"version":3,"file":"readDictionariesFromDisk.d.ts","names":[],"sources":["../../../src/utils/readDictionariesFromDisk.ts"],"mappings":";;;;;qBAOa,2BAA4B,IAAI,qBAAmB,sBAE7D"}

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

@@ -1,6 +1,6 @@
 //#region src/utils/reduceObjectFormat.d.ts
-type Primitive = string | number | boolean | null | undefined;
-type Recursive = Primitive | {
+export type Primitive = string | number | boolean | null | undefined;
+export type Recursive = Primitive | {
   [key: string]: Recursive;
 } | Array<Recursive>;
 /**
@@ -11,7 +11,7 @@ type Recursive = Primitive | {
  * reduceObjectFormat({ a: 1, b: 2 }, { a: 0 }) => { a: 1 }
  * reduceObjectFormat({ a: { x: 1, y: 2 } }, { a: { x: 0 } }) => { a: { x: 1 } }
  */
-declare const reduceObjectFormat: (source: Recursive, format: Recursive) => Recursive;
+export declare const reduceObjectFormat: (source: Recursive, format: Recursive) => Recursive;
 /**
  * Returns the subset of source whose keys are NOT present in the format object.
  * Inverse of reduceObjectFormat.
@@ -24,7 +24,6 @@ declare const reduceObjectFormat: (source: Recursive, format: Recursive) => Recu
  * excludeObjectFormat({ a: { x: 1, y: 2 } }, { a: { x: 0 } }) => { a: { y: 2 } }
  * excludeObjectFormat({ a: null, b: 2 }, { b: 0 }) => { a: null }
  */
-declare const excludeObjectFormat: (source: Recursive, format: Recursive) => Recursive | undefined;
+export declare const excludeObjectFormat: (source: Recursive, format: Recursive) => Recursive | undefined;
 //#endregion
-export { Primitive, Recursive, excludeObjectFormat, reduceObjectFormat };
 //# sourceMappingURL=reduceObjectFormat.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"reduceObjectFormat.d.ts","names":[],"sources":["../../../src/utils/reduceObjectFormat.ts"],"mappings":";KAAY;KAEA,YACR;GACG,cAAc;IACjB,MAAM;;;;;;;;;cAUG,qBAAkB,QACrB,WAAS,QACT,cACP;;;;;;;;;;;;;cAyCU,sBAAmB,QACtB,WAAS,QACT,cACP"}
+{"version":3,"file":"reduceObjectFormat.d.ts","names":[],"sources":["../../../src/utils/reduceObjectFormat.ts"],"mappings":";YAAY;YAEA,YACR;GACG,cAAc;IACjB,MAAM;;;;;;;;;qBAUG,qBAAkB,QACrB,WAAS,QACT,cACP;;;;;;;;;;;;;qBAyCU,sBAAmB,QACtB,WAAS,QACT,cACP"}

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

@@ -3,7 +3,6 @@
  * A more "unified" approach where each type (function, array, object, primitive)
  * is handled inside the main recursive body.
  */
-declare const resolveObjectPromises: <T = unknown>(entry: any) => Promise<T>;
+export declare const resolveObjectPromises: <T = unknown>(entry: any) => Promise<T>;
 //#endregion
-export { resolveObjectPromises };
 //# sourceMappingURL=resolveObjectPromises.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"resolveObjectPromises.d.ts","names":[],"sources":["../../../src/utils/resolveObjectPromises.ts"],"mappings":";;;;;cAIa,wBAA+B,aAAW,eAEpD,QAAQ"}
+{"version":3,"file":"resolveObjectPromises.d.ts","names":[],"sources":["../../../src/utils/resolveObjectPromises.ts"],"mappings":";;;;;qBAIa,wBAA+B,aAAW,eAEpD,QAAQ"}

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

@@ -1,5 +1,4 @@
 //#region src/utils/resolveRelativePath.d.ts
-declare const resolveRelativePath: (path: string, sourcePath: string, baseDir: string) => string;
+export declare const resolveRelativePath: (path: string, sourcePath: string, baseDir: string) => string;
 //#endregion
-export { resolveRelativePath };
 //# sourceMappingURL=resolveRelativePath.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"resolveRelativePath.d.ts","names":[],"sources":["../../../src/utils/resolveRelativePath.ts"],"mappings":";cAEa,sBAAmB,cAClB,oBACM"}
+{"version":3,"file":"resolveRelativePath.d.ts","names":[],"sources":["../../../src/utils/resolveRelativePath.ts"],"mappings":";qBAEa,sBAAmB,cAClB,oBACM"}

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

@@ -2,7 +2,7 @@
 /**
  * Context handed to the callback so it can interact with the lock it runs under.
  */
-type RunOnceContext = {
+export type RunOnceContext = {
   /**
    * Re-create the sentinel file after an operation that may have deleted it —
    * typically cleaning the output directory, which wipes the cache directory the
@@ -63,7 +63,6 @@ type RunOnceOptions = {
  *
  * @throws {Error} When there are unexpected filesystem errors
  */
-declare const runOnce: (sentinelFilePath: string, callback: (context: RunOnceContext) => void | Promise<void>, options?: RunOnceOptions) => Promise<void>;
+export declare const runOnce: (sentinelFilePath: string, callback: (context: RunOnceContext) => void | Promise<void>, options?: RunOnceOptions) => Promise<void>;
 //#endregion
-export { RunOnceContext, runOnce };
 //# sourceMappingURL=runOnce.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"runOnce.d.ts","names":[],"sources":["../../../src/utils/runOnce.ts"],"mappings":";;;;KA4BY;;;;;;;EAOV,iBAAiB;;KAGd;;;;EAIH,0BAA0B;;;;;;EAM1B;;;;;;EAMA;;;;;;;EAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwKW,UAAO,0BACM,WACb,SAAS,0BAA0B,eAAa,UACjD,mBAAc"}
+{"version":3,"file":"runOnce.d.ts","names":[],"sources":["../../../src/utils/runOnce.ts"],"mappings":";;;;YA4BY;;;;;;;EAOV,iBAAiB;;KAGd;;;;EAIH,0BAA0B;;;;;;EAM1B;;;;;;EAMA;;;;;;;EAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwKW,UAAO,0BACM,WACb,SAAS,0BAA0B,eAAa,UACjD,mBAAc"}

package/dist/types/utils/runParallel/bin.d.ts

@@ -8,7 +8,6 @@ type BinCallback = (err: Error | null, stdout?: string, code?: number) => void;
  * @param options Optional option for the spawn function.
  * @param done Callback function.
  */
-declare const run: (cmd: string, args: string[], options: SpawnOptions | BinCallback | undefined, done?: BinCallback) => void;
+export declare const run: (cmd: string, args: string[], options: SpawnOptions | BinCallback | undefined, done?: BinCallback) => void;
 //#endregion
-export { run };
 //# sourceMappingURL=bin.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bin.d.ts","names":[],"sources":["../../../../src/utils/runParallel/bin.ts"],"mappings":";;KAGK,eAAe,KAAK,cAAc,iBAAiB;;;;;;;;cAoB3C,MAAG,aACH,gBACG,SACL,eAAe,yBAAuB,OACxC"}
+{"version":3,"file":"bin.d.ts","names":[],"sources":["../../../../src/utils/runParallel/bin.ts"],"mappings":";;KAGK,eAAe,KAAK,cAAc,iBAAiB;;;;;;;;qBAoB3C,MAAG,aACH,gBACG,SACL,eAAe,yBAAuB,OACxC"}

package/dist/types/utils/runParallel/bootstrap.d.ts

@@ -1,5 +1,4 @@
 //#region src/utils/runParallel/bootstrap.d.ts
-declare const bootstrap: (_name: string) => void | Promise<void>;
+export declare const bootstrap: (_name: string) => void | Promise<void>;
 //#endregion
-export { bootstrap };
 //# sourceMappingURL=bootstrap.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","names":[],"sources":["../../../../src/utils/runParallel/bootstrap.ts"],"mappings":";cAIa,YAAS,yBAA2B"}
+{"version":3,"file":"bootstrap.d.ts","names":[],"sources":["../../../../src/utils/runParallel/bootstrap.ts"],"mappings":";qBAIa,YAAS,yBAA2B"}

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

@@ -1,5 +1,5 @@
 //#region src/utils/runParallel/index.d.ts
-type ParallelHandle = {
+export type ParallelHandle = {
   /**
    * Terminate the child and its whole process group.
    * @param signal Signal to send (default `SIGTERM`). Pass `SIGKILL` to force-kill
@@ -13,7 +13,6 @@ type ParallelHandle = {
  * Start a cross-platform parallel process using npm-run-all approach.
  * Accepts either a single string (e.g., 'next start') or an array of tokens (e.g., ['next', 'start']).
  */
-declare const runParallel: (proc?: string | string[]) => ParallelHandle;
+export declare const runParallel: (proc?: string | string[]) => ParallelHandle;
 //#endregion
-export { ParallelHandle, runParallel };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/utils/runParallel/index.ts"],"mappings":";KAIY;;;;;;EAMV,OAAO,SAAS,OAAO;EACvB,QAAQ;EACR;;;;;;cAOW,cAAW,6BAA+B"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/utils/runParallel/index.ts"],"mappings":";YAIY;;;;;;EAMV,OAAO,SAAS,OAAO;EACvB,QAAQ;EACR;;;;;;qBAOW,cAAW,6BAA+B"}

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

@@ -18,7 +18,6 @@ type ListCallback<T extends ListOptions | undefined> = (err: Error | null, list?
  * @param callback Called when the list is ready. If not provided a promise is returned instead.
  * @returns Only when the callback is not provided.
  */
-declare const list: <T extends ListOptions | undefined>(pid: number | string, options?: T | ListCallback<T>, callback?: ListCallback<T>) => Promise<ResultType<T>> | undefined;
+export declare const list: <T extends ListOptions | undefined>(pid: number | string, options?: T | ListCallback<T>, callback?: ListCallback<T>) => Promise<ResultType<T>> | undefined;
 //#endregion
-export { list };
 //# sourceMappingURL=pidTree.d.ts.map

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

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

package/dist/types/utils/runParallel/ps.d.ts

@@ -5,7 +5,6 @@ type ProcessListCallback = (err: Error | null, list?: ProcessList) => void;
  * Gets the list of all the pids of the system through the ps command.
  * @param callback Callback function with error and process list.
  */
-declare const ps: (callback: ProcessListCallback) => void;
+export declare const ps: (callback: ProcessListCallback) => void;
 //#endregion
-export { ps };
 //# sourceMappingURL=ps.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ps.d.ts","names":[],"sources":["../../../../src/utils/runParallel/ps.ts"],"mappings":";KAGK;KACA,uBAAuB,KAAK,cAAc,OAAO;;;;;cAMzC,KAAE,UAAc"}
+{"version":3,"file":"ps.d.ts","names":[],"sources":["../../../../src/utils/runParallel/ps.ts"],"mappings":";KAGK;KACA,uBAAuB,KAAK,cAAc,OAAO;;;;;qBAMzC,KAAE,UAAc"}

package/dist/types/utils/runParallel/runTask.d.ts

@@ -20,7 +20,6 @@ interface RunTaskOptions {
  * Note: This is a simplified version for our use case.
  * The full implementation would require the actual runTask function from npm-run-all.
  */
-declare const runTasks: (tasks: string[], options: RunTaskOptions) => Promise<TaskResult[]>;
+export declare const runTasks: (tasks: string[], options: RunTaskOptions) => Promise<TaskResult[]>;
 //#endregion
-export { runTasks };
 //# sourceMappingURL=runTask.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"runTask.d.ts","names":[],"sources":["../../../../src/utils/runParallel/runTask.ts"],"mappings":";UA8EU;EACR;EACA;EACA;;UAQQ;EACR,QAAQ,OAAO;EACf,SAAS,OAAO;EAChB;EACA;EACA;EACA;;;;;;;;;;cAmBW,WAAQ,iBACJ,SACN,mBACR,QAAQ"}
+{"version":3,"file":"runTask.d.ts","names":[],"sources":["../../../../src/utils/runParallel/runTask.ts"],"mappings":";UA8EU;EACR;EACA;EACA;;UAQQ;EACR,QAAQ,OAAO;EACf,SAAS,OAAO;EAChB;EACA;EACA;EACA;;;;;;;;;;qBAmBW,WAAQ,iBACJ,SACN,mBACR,QAAQ"}

package/dist/types/utils/runParallel/spawnPosix.d.ts

@@ -13,7 +13,6 @@ import { ChildProcess, SpawnOptions } from "node:child_process";
  * @returns A ChildProcess instance of new process.
  * @private
  */
-declare const spawnPosix: (command: string, args: string[], options: SpawnOptions) => ChildProcess;
+export declare const spawnPosix: (command: string, args: string[], options: SpawnOptions) => ChildProcess;
 //#endregion
-export { spawnPosix };
 //# sourceMappingURL=spawnPosix.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"spawnPosix.d.ts","names":[],"sources":["../../../../src/utils/runParallel/spawnPosix.ts"],"mappings":";;;;;;;;;;;;;;;cA6Da,aAAU,iBACN,gBACD,SACL,iBACR"}
+{"version":3,"file":"spawnPosix.d.ts","names":[],"sources":["../../../../src/utils/runParallel/spawnPosix.ts"],"mappings":";;;;;;;;;;;;;;;qBA6Da,aAAU,iBACN,gBACD,SACL,iBACR"}

package/dist/types/utils/runParallel/spawnWin32.d.ts

@@ -13,7 +13,6 @@ import { ChildProcess, SpawnOptions } from "node:child_process";
  * @returns A ChildProcess instance of new process.
  * @private
  */
-declare const spawnWin32: (command: string, args: string[], options: SpawnOptions) => ChildProcess;
+export declare const spawnWin32: (command: string, args: string[], options: SpawnOptions) => ChildProcess;
 //#endregion
-export { spawnWin32 };
 //# sourceMappingURL=spawnWin32.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"spawnWin32.d.ts","names":[],"sources":["../../../../src/utils/runParallel/spawnWin32.ts"],"mappings":";;;;;;;;;;;;;;;cAoDa,aAAU,iBACN,gBACD,SACL,iBACR"}
+{"version":3,"file":"spawnWin32.d.ts","names":[],"sources":["../../../../src/utils/runParallel/spawnWin32.ts"],"mappings":";;;;;;;;;;;;;;;qBAoDa,aAAU,iBACN,gBACD,SACL,iBACR"}

package/dist/types/utils/runParallel/wmic.d.ts

@@ -5,7 +5,6 @@ type ProcessListCallback = (err: Error | null, list?: ProcessList) => void;
  * Gets the list of all the pids of the system through the wmic command.
  * @param callback Callback function with error and process list.
  */
-declare const wmic: (callback: ProcessListCallback) => void;
+export declare const wmic: (callback: ProcessListCallback) => void;
 //#endregion
-export { wmic };
 //# sourceMappingURL=wmic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"wmic.d.ts","names":[],"sources":["../../../../src/utils/runParallel/wmic.ts"],"mappings":";KAIK;KACA,uBAAuB,KAAK,cAAc,OAAO;;;;;cAMzC,OAAI,UAAc"}
+{"version":3,"file":"wmic.d.ts","names":[],"sources":["../../../../src/utils/runParallel/wmic.ts"],"mappings":";KAIK;KACA,uBAAuB,KAAK,cAAc,OAAO;;;;;qBAMzC,OAAI,UAAc"}

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

@@ -1,5 +1,4 @@
 //#region src/utils/sortAlphabetically.d.ts
-declare const sortAlphabetically: (a: string, b: string) => number;
+export declare const sortAlphabetically: (a: string, b: string) => number;
 //#endregion
-export { sortAlphabetically };
 //# sourceMappingURL=sortAlphabetically.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sortAlphabetically.d.ts","names":[],"sources":["../../../src/utils/sortAlphabetically.ts"],"mappings":";cAAa,qBAAkB,WAAa"}
+{"version":3,"file":"sortAlphabetically.d.ts","names":[],"sources":["../../../src/utils/sortAlphabetically.ts"],"mappings":";qBAAa,qBAAkB,WAAa"}

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

@@ -1,5 +1,4 @@
 //#region src/utils/splitTextByLine.d.ts
-declare const splitTextByLines: (text: string) => string[];
+export declare const splitTextByLines: (text: string) => string[];
 //#endregion
-export { splitTextByLines };
 //# sourceMappingURL=splitTextByLine.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"splitTextByLine.d.ts","names":[],"sources":["../../../src/utils/splitTextByLine.ts"],"mappings":";cAAa,mBAAgB"}
+{"version":3,"file":"splitTextByLine.d.ts","names":[],"sources":["../../../src/utils/splitTextByLine.ts"],"mappings":";qBAAa,mBAAgB"}

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

@@ -17,7 +17,6 @@ type VerifyIdenticObjectFormatResult = {
  * @param path - Current path in the object tree (for error messages)
  * @returns true if structures match, throws error with details if they don't
  */
-declare const verifyIdenticObjectFormat: (object: RecursiveType, expectedFormat: RecursiveType, path?: string) => VerifyIdenticObjectFormatResult;
+export declare const verifyIdenticObjectFormat: (object: RecursiveType, expectedFormat: RecursiveType, path?: string) => VerifyIdenticObjectFormatResult;
 //#endregion
-export { verifyIdenticObjectFormat };
 //# sourceMappingURL=verifyIdenticObjectFormat.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"verifyIdenticObjectFormat.d.ts","names":[],"sources":["../../../src/utils/verifyIdenticObjectFormat.ts"],"mappings":";KAAK;KAEA,gBACD;GACG,cAAc;IACjB,MAAM;KAEL;EACH;EACA;;;;;;;;;;;;cAaW,4BAAyB,QAC5B,eAAa,gBACL,eAAa,kBAE5B"}
+{"version":3,"file":"verifyIdenticObjectFormat.d.ts","names":[],"sources":["../../../src/utils/verifyIdenticObjectFormat.ts"],"mappings":";KAAK;KAEA,gBACD;GACG,cAAc;IACjB,MAAM;KAEL;EACH;EACA;;;;;;;;;;;;qBAaW,4BAAyB,QAC5B,eAAa,gBACL,eAAa,kBAE5B"}

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

@@ -0,0 +1,44 @@
+//#region src/utils/withFileLock.d.ts
+type WithFileLockOptions = {
+  /**
+   * How long a lock may be held before it is considered abandoned and taken
+   * over, in milliseconds.
+   *
+   * @default 30000 = 30 seconds
+   */
+  staleTimeoutMs?: number;
+  /**
+   * How long to wait for the lock before running the callback anyway, in
+   * milliseconds. Giving up serialises nothing, but it is strictly better than
+   * deadlocking a build behind a lock that never clears.
+   *
+   * @default 60000 = 1 minute
+   */
+  acquireTimeoutMs?: number;
+};
+/**
+ * Runs `callback` under a cross-process mutex materialised by a lock file.
+ *
+ * Unlike `runOnce`, which lets one process do the work and the others skip it,
+ * every caller here runs the callback — just never at the same time. This is
+ * what shared, read-modify-write outputs need (e.g. building the `.intlayer`
+ * dictionaries, which merges every dictionary on disk): concurrent runs would
+ * each read a half-written state.
+ *
+ * The lock is released even when the callback throws, and its error is
+ * re-thrown to the caller unchanged.
+ *
+ * @param lockFilePath - Path of the lock file coordinating the callers.
+ * @param callback - The critical section.
+ * @param options - Staleness and acquisition timeouts.
+ *
+ * @example
+ * ```typescript
+ * await withFileLock(join(cacheDir, 'build-dictionary.lock'), () =>
+ *   buildDictionary([dictionary], configuration)
+ * );
+ * ```
+ */
+export declare const withFileLock: <T>(lockFilePath: string, callback: () => T | Promise<T>, options?: WithFileLockOptions) => Promise<T>;
+//#endregion
+//# sourceMappingURL=withFileLock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withFileLock.d.ts","names":[],"sources":["../../../src/utils/withFileLock.ts"],"mappings":";KAYK;;;;;;;EAOH;;;;;;;;EAQA;;;;;;;;;;;;;;;;;;;;;;;;;qBA0HW,eAAsB,GAAC,sBACd,gBACJ,IAAI,QAAQ,IAAE,UACpB,wBACT,QAAQ"}

package/dist/types/watcher.d.ts

@@ -7,10 +7,9 @@ type WatchOptions = {
   skipPrepare?: boolean;
   persistent?: boolean;
 };
-declare const watch: (options?: WatchOptions) => Promise<{
+export declare const watch: (options?: WatchOptions) => Promise<{
   unsubscribe: () => Promise<void>;
 }[]>;
-declare const buildAndWatchIntlayer: (options?: WatchOptions) => Promise<void>;
+export declare const buildAndWatchIntlayer: (options?: WatchOptions) => Promise<void>;
 //#endregion
-export { buildAndWatchIntlayer, watch };
 //# sourceMappingURL=watcher.d.ts.map

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

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

package/dist/types/writeConfiguration/generateConfigurationContent.d.ts

@@ -28,7 +28,6 @@ import { IntlayerConfig } from "@intlayer/types/config";
  * @param format - Module format to emit (`esm` for `.mjs`, `cjs` for `.cjs`).
  * @returns The file content as a string.
  */
-declare const generateConfigurationContent: (configuration: IntlayerConfig, format: 'cjs' | 'esm') => string;
+export declare const generateConfigurationContent: (configuration: IntlayerConfig, format: 'cjs' | 'esm') => string;
 //#endregion
-export { generateConfigurationContent };
 //# sourceMappingURL=generateConfigurationContent.d.ts.map

package/dist/types/writeConfiguration/generateConfigurationContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateConfigurationContent.d.ts","names":[],"sources":["../../../src/writeConfiguration/generateConfigurationContent.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Ba,+BAA4B,eACxB,gBAAc"}
+{"version":3,"file":"generateConfigurationContent.d.ts","names":[],"sources":["../../../src/writeConfiguration/generateConfigurationContent.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+Ba,+BAA4B,eACxB,gBAAc"}

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

@@ -1,7 +1,6 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/writeConfiguration/index.d.ts
-declare const isCachedConfigurationUpToDate: (configuration: IntlayerConfig) => Promise<boolean | null>;
-declare const writeConfiguration: (configuration: IntlayerConfig) => Promise<void>;
+export declare const isCachedConfigurationUpToDate: (configuration: IntlayerConfig) => Promise<boolean | null>;
+export declare const writeConfiguration: (configuration: IntlayerConfig) => Promise<void>;
 //#endregion
-export { isCachedConfigurationUpToDate, writeConfiguration };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/writeConfiguration/index.ts"],"mappings":";;cAMa,gCAA6B,eACzB,mBACd;cAWU,qBAAkB,eAAyB,mBAAc"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/writeConfiguration/index.ts"],"mappings":";;qBAMa,gCAA6B,eACzB,mBACd;qBAWU,qBAAkB,eAAyB,mBAAc"}

package/dist/types/writeContentDeclaration/detectExportedComponentName.d.ts

@@ -6,7 +6,6 @@
  *   - export function MyComponent(...)
  *   - export default function MyComponent(...)
  */
-declare const detectExportedComponentName: (fileText: string) => string | null;
+export declare const detectExportedComponentName: (fileText: string) => string | null;
 //#endregion
-export { detectExportedComponentName };
 //# sourceMappingURL=detectExportedComponentName.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"detectExportedComponentName.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/detectExportedComponentName.ts"],"mappings":";;;;;;;;cAOa,8BAA2B"}
+{"version":3,"file":"detectExportedComponentName.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/detectExportedComponentName.ts"],"mappings":";;;;;;;;qBAOa,8BAA2B"}

package/dist/types/writeContentDeclaration/dictionaryStatus.d.ts

@@ -1,5 +1,4 @@
 //#region src/writeContentDeclaration/dictionaryStatus.d.ts
-type DictionaryStatus = 'pending' | 'fetching' | 'up-to-date' | 'replaced' | 'updated' | 'fetched' | 'unknown' | 'error' | 'imported' | 'reimported in JSON' | 'new content file' | 'created';
+export type DictionaryStatus = 'pending' | 'fetching' | 'up-to-date' | 'replaced' | 'updated' | 'fetched' | 'unknown' | 'error' | 'imported' | 'reimported in JSON' | 'new content file' | 'created';
 //#endregion
-export { DictionaryStatus };
 //# sourceMappingURL=dictionaryStatus.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dictionaryStatus.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/dictionaryStatus.ts"],"mappings":";KAAY"}
+{"version":3,"file":"dictionaryStatus.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/dictionaryStatus.ts"],"mappings":";YAAY"}

package/dist/types/writeContentDeclaration/processContentDeclarationContent.d.ts

@@ -7,7 +7,6 @@ import { Dictionary } from "@intlayer/types/dictionary";
  *
  * And write external sources as file content if necessary.
  */
-declare const processContentDeclarationContent: (dictionary: Dictionary) => Promise<any>;
+export declare const processContentDeclarationContent: (dictionary: Dictionary) => Promise<any>;
 //#endregion
-export { processContentDeclarationContent };
 //# sourceMappingURL=processContentDeclarationContent.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"processContentDeclarationContent.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/processContentDeclarationContent.ts"],"mappings":";;;;;;;;;cAiIa,mCAAgC,YAC/B,eAAU"}
+{"version":3,"file":"processContentDeclarationContent.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/processContentDeclarationContent.ts"],"mappings":";;;;;;;;;qBAiIa,mCAAgC,YAC/B,eAAU"}

package/dist/types/writeContentDeclaration/transformJSFile.d.ts

@@ -4,7 +4,6 @@ import { Locale } from "@intlayer/types/allLocales";
 /**
  * Updates a JS/TS file seamlessly to map new localization keys, arrays, complex nodes and nested dictionaries gracefully using AST updates via Recast parser.
  */
-declare const transformJSFile: (fileContent: string, dictionary: Dictionary, fallbackLocale?: Locale, noMetadata?: boolean) => Promise<string>;
+export declare const transformJSFile: (fileContent: string, dictionary: Dictionary, fallbackLocale?: Locale, noMetadata?: boolean) => Promise<string>;
 //#endregion
-export { transformJSFile };
 //# sourceMappingURL=transformJSFile.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transformJSFile.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/transformJSFile.ts"],"mappings":";;;;;;cAixBa,kBAAe,qBACP,YACP,YAAU,iBACL,QAAM,yBAEtB"}
+{"version":3,"file":"transformJSFile.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/transformJSFile.ts"],"mappings":";;;;;;qBAixBa,kBAAe,qBACP,YACP,YAAU,iBACL,QAAM,yBAEtB"}

package/dist/types/writeContentDeclaration/transformJSONFile.d.ts

@@ -1,6 +1,5 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/writeContentDeclaration/transformJSONFile.d.ts
-declare const transformJSONFile: (fileContent: string, dictionary: Dictionary, noMetadata?: boolean) => string;
+export declare const transformJSONFile: (fileContent: string, dictionary: Dictionary, noMetadata?: boolean) => string;
 //#endregion
-export { transformJSONFile };
 //# sourceMappingURL=transformJSONFile.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transformJSONFile.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/transformJSONFile.ts"],"mappings":";;cA8Ia,oBAAiB,qBACT,YACP,YAAU"}
+{"version":3,"file":"transformJSONFile.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/transformJSONFile.ts"],"mappings":";;qBA8Ia,oBAAiB,qBACT,YACP,YAAU"}