@intlayer/engine 9.1.3 → 9.3.0

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

@@ -1,7 +1,21 @@
 import { LocalizedDictionaryOutput } from "./writeDynamicDictionary.js";
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/buildIntlayerDictionary/writeFetchDictionary.d.ts
-declare const generateDictionaryEntryPoint: (key: string, locales: string[], relativePrefix: string, format?: 'cjs' | 'esm') => string;
+/**
+ * Generates the live (fetch-mode) entry point of a dictionary.
+ *
+ * When the dictionary references others through `nest()`, those are fetched
+ * live alongside it and attached as `nestedDictionaries`, so a remote edit to a
+ * nested dictionary propagates through the reference instead of resolving
+ * against the build-time snapshot.
+ *
+ * @param key - The dictionary key.
+ * @param locales - Locales to emit a loader for.
+ * @param relativePrefix - Relative path to the dynamic dictionaries directory.
+ * @param format - Output module format.
+ * @param nestedKeys - Keys referenced through `nest()`, transitively.
+ */
+declare const generateDictionaryEntryPoint: (key: string, locales: string[], relativePrefix: string, format?: 'cjs' | 'esm', nestedKeys?: string[]) => string;
 /**
  * Write the localized dictionaries to the dictionariesDir
  * @param mergedDictionaries - The merged dictionaries
@@ -18,7 +32,7 @@ declare const generateDictionaryEntryPoint: (key: string, locales: string[], rel
  * // .intlayer/fetch_dictionary/home.cjs
  * ```
  */
-declare const writeFetchDictionary: (dynamicDictionaries: LocalizedDictionaryOutput, configuration: IntlayerConfig, formats?: ('cjs' | 'esm')[]) => Promise<LocalizedDictionaryOutput>;
+declare const writeFetchDictionary: (dynamicDictionaries: LocalizedDictionaryOutput, configuration: IntlayerConfig, formats?: ('cjs' | 'esm')[], nestedDictionaryGraph?: Map<string, Set<string>>) => Promise<LocalizedDictionaryOutput>;
 //#endregion
 export { generateDictionaryEntryPoint, writeFetchDictionary };
 //# sourceMappingURL=writeFetchDictionary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"writeFetchDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"mappings":";;;cAUa,+BAA4B,aAC5B,mBACM,wBACK;;;;;;;;;;;;;;;;;cAmDX,uBAAoB,qBACV,2BAAyB,eAC/B,gBAAc,gCAE5B,QAAQ"}
+{"version":3,"file":"writeFetchDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"mappings":";;;;;;;;;;;;;;;;;cAqDa,+BAA4B,aAC5B,mBACM,wBACK,wBACD;;;;;;;;;;;;;;;;;cA2FV,uBAAoB,qBACV,2BAAyB,eAC/B,gBAAc,6BACH,wBACH,YAAY,iBAClC,QAAQ"}

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

@@ -0,0 +1,54 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+//#region src/buildIntlayerDictionary/writeNestedDictionary.d.ts
+/**
+ * Subdirectory of `dictionariesDir` holding the companion modules. Nested under
+ * the compiled dictionaries so both stay together and are cleaned as one, and
+ * because the `**\/*.json` globs listing compiled dictionaries never match the
+ * `.mjs` / `.cjs` files written here.
+ */
+declare const NESTED_DICTIONARIES_SUBDIR = "nested";
+/**
+ * Path of the companion module carrying the `nest()` targets of a dictionary.
+ *
+ * Shared with the bundler plugins, which re-point the static import they inject
+ * at a `useIntlayer` call site to this module whenever the dictionary has nest
+ * targets.
+ *
+ * @param dictionariesDir - The compiled dictionaries directory.
+ * @param key - The dictionary key.
+ * @param extension - Module extension, `'mjs'` (default) or `'cjs'`.
+ */
+declare const getNestedDictionaryPath: (dictionariesDir: string, key: string, extension?: 'mjs' | 'cjs') => string;
+/**
+ * Generates a companion module that re-exports a compiled dictionary with its
+ * `nest()` targets attached.
+ *
+ * The optimizer imports this instead of the raw JSON, so `getNesting` resolves
+ * the reference from `nestedDictionaries` rather from the global registry
+ * — which lets the registry be stripped, and puts each nest target in the same
+ * chunk as the dictionary that references it.
+ *
+ * @param key - The dictionary key.
+ * @param nestedKeys - Keys of the dictionaries it references, transitively.
+ * @param format - Output module format.
+ *
+ * @example
+ * ```js
+ * import _dictionary from '../dashboard.json' with { type: 'json' };
+ * import _1a2b3c from '../common.json' with { type: 'json' };
+ *
+ * export default { ..._dictionary, nestedDictionaries: { 'common': _1a2b3c } };
+ * ```
+ */
+declare const generateNestedDictionaryEntryPoint: (key: string, nestedKeys: string[], format?: 'cjs' | 'esm') => string;
+/**
+ * Writes one companion module per dictionary holding `nest()` references.
+ *
+ * @param nestedDictionaryGraph - Dictionary key → keys it nests, transitively.
+ * @param configuration - The resolved intlayer configuration.
+ * @param formats - Module formats to emit.
+ */
+declare const writeNestedDictionaries: (nestedDictionaryGraph: Map<string, Set<string>>, configuration: IntlayerConfig, formats?: ('cjs' | 'esm')[]) => Promise<void>;
+//#endregion
+export { NESTED_DICTIONARIES_SUBDIR, generateNestedDictionaryEntryPoint, getNestedDictionaryPath, writeNestedDictionaries };
+//# sourceMappingURL=writeNestedDictionary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writeNestedDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeNestedDictionary.ts"],"mappings":";;;;;;;;cAgBa;;;;;;;;;;;;cAoBA,0BAAuB,yBACX,aACZ;;;;;;;;;;;;;;;;;;;;;;cA0BA,qCAAkC,aAClC,sBACS;;;;;;;;cAkDT,0BAAuB,uBACX,YAAY,cAAY,eAChC,gBAAc,gCAE5B"}

package/dist/types/docReview/alignBlocks.d.ts

@@ -2,10 +2,12 @@ import { AlignmentPair, FingerprintedBlock } from "./types.js";
 //#region src/docReview/alignBlocks.d.ts
 /**
  * Align the blocks of a base document with the blocks of its translation using a
- * Needleman–Wunsch global alignment over anchor similarity and block type.
+ * Needleman–Wunsch global alignment over heading depth, anchor similarity and
+ * block type.
  *
  * Because prose differs across languages, the score is weighted toward the
- * structural anchor (digits and symbols) rather than the words themselves.
+ * structural signals — heading depth first, then the anchor (digits and symbols)
+ * — rather than the words themselves.
  *
  * @param baseBlocks - Blocks of the base (source) document.
  * @param targetBlocks - Blocks of the target (translated) document.

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

@@ -1 +1 @@
-{"version":3,"file":"alignBlocks.d.ts","names":[],"sources":["../../../src/docReview/alignBlocks.ts"],"mappings":";;;;;;;;;;;;;cAca,2BAAwB,YACvB,sBAAoB,cAClB,yBACb"}
+{"version":3,"file":"alignBlocks.d.ts","names":[],"sources":["../../../src/docReview/alignBlocks.ts"],"mappings":";;;;;;;;;;;;;;;cAgEa,2BAAwB,YACvB,sBAAoB,cAClB,yBACb"}

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

@@ -1 +1 @@
-{"version":3,"file":"rebuildDocument.d.ts","names":[],"sources":["../../../src/docReview/rebuildDocument.ts"],"mappings":";;;;;;KAMY;;EAEV,WAAW;;EAEX;;EAEA;;KAGU;EACV,YAAY;EACZ,cAAc;EACd,MAAM;;KAGI;EACV,kBAAkB;;;;;;;;;;cAWP,6BAAwB,YAAA,cAAA,QAIlC,iBAAe;;;;;;;;;;cAmCL,wBAAqB,MAC1B,eAAa,cACL,sBAAoB,kBAChB"}
+{"version":3,"file":"rebuildDocument.d.ts","names":[],"sources":["../../../src/docReview/rebuildDocument.ts"],"mappings":";;;;;;KAMY;;EAEV,WAAW;;EAEX;;EAEA;;KAGU;EACV,YAAY;EACZ,cAAc;EACd,MAAM;;KAGI;EACV,kBAAkB;;;;;;;;;;cAWP,6BAAwB,YAAA,cAAA,QAIlC,iBAAe;;;;;;;;;;cAmDL,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":";;;;;;;;;;;;;;;;cAmCa,kBAAe,iBAAmB;;;;;;;;;;;;;;;;;;;cAgHlC,kBAAe,iBAAmB"}
+{"version":3,"file":"segmentDocument.d.ts","names":[],"sources":["../../../src/docReview/segmentDocument.ts"],"mappings":";;;;;;;;;;;;;;;;cAoDa,kBAAe,iBAAmB;;;;;;;;;;;;;;;;;;;cAuIlC,kBAAe,iBAAmB"}

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

@@ -11,6 +11,15 @@ type BlockType = 'heading' | 'paragraph' | 'list_item' | 'code_block' | 'blockqu
 type Block = {
   type: BlockType;
   content: string;
+  /**
+   * Depth of the ATX heading opening the block (`#` → 1, `######` → 6), or
+   * `null` when the block does not start with a heading.
+   *
+   * Heading depth is the one structural signal that survives translation, so it
+   * is used as decisive evidence when aligning a document with its translation:
+   * a `##` section is never the counterpart of a `###` section.
+   */
+  headingDepth: number | null;
   /** 1-based line number where the block starts (inclusive). */
   lineStart: number;
   /** 1-based line number where the block ends (inclusive). */

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/docReview/types.ts"],"mappings":";;;;;;KAKY;;;;KAcA;EACV,MAAM;EACN;;EAEA;;EAEA;;;;;KAMU,kBAAkB;;EAE5B;;EAEA;;;;;KAMU,qBAAqB;EAC/B;EACA;EACA;EACA;;;;;;;;KASU;EACV;EACA;EACA;;;;;KAMU;EACN;EAAe;EAAmB;;EAClC;EAAgB;EAAmB;;EACnC;EAAoB;;EACpB;EAAgB;;KAEV;EACV,SAAS;;;KAIC;KAEA;;EAEV;;EAEA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/docReview/types.ts"],"mappings":";;;;;;KAKY;;;;KAcA;EACV,MAAM;EACN;;;;;;;;;EASA;;EAEA;;EAEA;;;;;KAMU,kBAAkB;;EAE5B;;EAEA;;;;;KAMU,qBAAqB;EAC/B;EACA;EACA;EACA;;;;;;;;KASU;EACV;EACA;EACA;;;;;KAMU;EACN;EAAe;EAAmB;;EAClC;EAAgB;EAAmB;;EACnC;EAAoB;;EACpB;EAAgB;;KAEV;EACV,SAAS;;;KAIC;KAEA;;EAEV;;EAEA"}

package/dist/types/fetchDistantDictionaries.d.ts

@@ -6,9 +6,35 @@ type FetchDistantDictionariesOptions = {
   dictionaryKeys: string[];
   newDictionariesPath?: string;
   logPrefix?: string;
+  /**
+   * Number of dictionaries fetched by a single request.
+   * @default 3
+   */
+  dictionariesPerRequest?: number;
+  /**
+   * Number of requests kept in flight at the same time.
+   * @default 5
+   */
+  parallelRequests?: number;
+  /**
+   * Number of retries performed when a batch request fails.
+   * @default 2
+   */
+  maxRetry?: number;
+  /**
+   * Delay between two attempts of a failing batch request, in milliseconds.
+   * @default 250
+   */
+  retryDelay?: number;
 };
 /**
  * Fetch distant dictionaries and update the logger with their statuses.
+ *
+ * Keys are grouped into batches fetched by a single request each, and those
+ * requests are kept in flight together — by default 5 concurrent requests of 3
+ * dictionaries, so 15 dictionaries travel at any given time. A slot is refilled
+ * as soon as its request settles, so no batch waits for the whole wave.
+ * Failing requests are retried before their keys are reported as errors.
  */
 declare const fetchDistantDictionaries: (options: FetchDistantDictionariesOptions, onStatusUpdate?: (status: DictionariesStatus[]) => void) => Promise<DictionaryAPI[]>;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"fetchDistantDictionaries.d.ts","names":[],"sources":["../../src/fetchDistantDictionaries.ts"],"mappings":";;;;KASK;EACH;EACA;EACA;;;;;cAMW,2BAAwB,SAC1B,iCAA+B,kBACtB,QAAQ,kCACzB,QAAQ"}
+{"version":3,"file":"fetchDistantDictionaries.d.ts","names":[],"sources":["../../src/fetchDistantDictionaries.ts"],"mappings":";;;;KAqDK;EACH;EACA;EACA;;;;;EAKA;;;;;EAKA;;;;;EAKA;;;;;EAKA;;;;;;;;;;;cAYW,2BAAwB,SAC1B,iCAA+B,kBACtB,QAAQ,kCACzB,QAAQ"}

package/dist/types/formatDictionary.d.ts

@@ -8,6 +8,7 @@ declare const formatDictionaryOutput: (dictionary: Dictionary, format: Dictionar
   projectIds?: string[];
   localId?: import("@intlayer/types").LocalDictionaryId;
   localIds?: import("@intlayer/types").LocalDictionaryId[];
+  nestedDictionaries?: Record<import("@intlayer/types").DictionaryKey, unknown>;
   key: import("@intlayer/types").DictionaryKey;
   title?: string;
   description?: string;
@@ -34,6 +35,7 @@ declare const formatDictionariesOutput: (dictionaries: Dictionary[], format: Dic
   projectIds?: string[];
   localId?: import("@intlayer/types").LocalDictionaryId;
   localIds?: import("@intlayer/types").LocalDictionaryId[];
+  nestedDictionaries?: Record<import("@intlayer/types").DictionaryKey, unknown>;
   key: import("@intlayer/types").DictionaryKey;
   title?: string;
   description?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"formatDictionary.d.ts","names":[],"sources":["../../src/formatDictionary.ts"],"mappings":";;cAYa,mBAAgB,YAAgB,eAAa;cAoC7C,qBAAkB,cACf,iBACb,QAAQ;cAEE,yBAAsB,YACrB,YAAU,QACd;;;;;;;;;;;;;;;;;;;;;;;;;IAmCT;cAEY,2BAAwB,cACrB,cAAY,QAClB;;;;;;;;;;;;;;;;;;;;;;;;;IAEoE"}
+{"version":3,"file":"formatDictionary.d.ts","names":[],"sources":["../../src/formatDictionary.ts"],"mappings":";;cAYa,mBAAgB,YAAgB,eAAa;cAoC7C,qBAAkB,cACf,iBACb,QAAQ;cAEE,yBAAsB,YACrB,YAAU,QACd;;;;;;;;;;;;;;;;;;;;;;;;;;IAmCT;cAEY,2BAAwB,cACrB,cAAY,QAClB;;;;;;;;;;;;;;;;;;;;;;;;;;IAEoE"}

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

@@ -14,6 +14,7 @@ declare class DictionariesLogger {
   private remoteError;
   private pluginTotal;
   private pluginDone;
+  private pluginNames;
   private pluginError;
   constructor();
   setExpectRemote(expect: boolean): void;
@@ -24,9 +25,23 @@ declare class DictionariesLogger {
   private startSpinner;
   private stopSpinner;
   setRemoteError: (error?: Error) => void;
+  /**
+   * Register the names of the plugins providing dictionaries.
+   * They are displayed next to the plugin progress counters, e.g.
+   * `Plugin content: 6/6 (sync-json, load-po)`.
+   *
+   * @param names - Names of the plugins exposing a `loadDictionaries` hook
+   */
+  setPluginNames(names: string[]): void;
   setPluginTotal(total: number): void;
   setPluginDone(done: number): void;
-  setPluginError(error?: Error): void;
+  /**
+   * Flag the plugin line as errored.
+   *
+   * @param error - Error thrown while loading the plugin dictionaries
+   * @param pluginName - Name of the plugin that threw, prefixed to the message
+   */
+  setPluginError(error?: Error, pluginName?: string): void;
   private render;
   private computeProgress;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"log.d.ts","names":[],"sources":["../../../src/loadDictionaries/log.ts"],"mappings":";;cAYa;UACH;UACA;UACA;UACA;mBACS;UACT;mBACS;UACT;UACA;UACA;UACA;UACA;UACA;UACA;EAER;EAIA,gBAAgB;EAIhB;EAOA;EAIA,OAAO,aAAa;EAyBpB;UAOQ;UAQA;EAMD,iBAAc,QAAY;EAQjC,eAAe;EASf,cAAc;EAMd,eAAe,QAAQ;UAMf;UAqGA"}
+{"version":3,"file":"log.d.ts","names":[],"sources":["../../../src/loadDictionaries/log.ts"],"mappings":";;cAYa;UACH;UACA;UACA;UACA;mBACS;UACT;mBACS;UACT;UACA;UACA;UACA;UACA;UACA;UACA;UACA;EAER;EAIA,gBAAgB;EAIhB;EAOA;EAIA,OAAO,aAAa;EAyBpB;UAOQ;UAQA;EAMD,iBAAc,QAAY;;;;;;;;EAejC,eAAe;EAOf,eAAe;EASf,cAAc;;;;;;;EAYd,eAAe,QAAQ,OAAO;UAStB;UA0GA"}

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

@@ -0,0 +1,16 @@
+//#region src/utils/chunkArray.d.ts
+/**
+ * Splits an array into consecutive chunks of at most `chunkSize` items.
+ *
+ * The last chunk holds the remainder and may be smaller. An empty input, or a
+ * `chunkSize` lower than 1, returns an empty list of chunks.
+ *
+ * @example
+ * ```ts
+ * chunkArray(['a', 'b', 'c', 'd', 'e'], 2); // [['a', 'b'], ['c', 'd'], ['e']]
+ * ```
+ */
+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

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

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

@@ -1,6 +1,7 @@
 import { Extension, Format, getExtensionFromFormat, getFormatFromExtension } from "./getFormatFromExtension.js";
 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 { formatLocale, formatPath } from "./formatter.js";
 import { getChunk } from "./getChunk.js";
@@ -13,9 +14,9 @@ import { getGlobalLimiter, getTaskLimiter, parallelizeGlobal } from "./paralleli
 import { Primitive, Recursive, excludeObjectFormat, reduceObjectFormat } from "./reduceObjectFormat.js";
 import { resolveObjectPromises } from "./resolveObjectPromises.js";
 import { resolveRelativePath } from "./resolveRelativePath.js";
-import { runOnce } from "./runOnce.js";
+import { RunOnceContext, runOnce } from "./runOnce.js";
 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, assembleJSON, autoDecorateContent, buildComponentFilesList, chunkJSON, excludeObjectFormat, formatLocale, formatPath, getChunk, getContentExtension, getExtensionFromFormat, getFormatFromExtension, getGlobalLimiter, getPathHash, getTaskLimiter, mergeChunks, pLimit, parallelize, parallelizeGlobal, reconstructFromSingleChunk, reduceObjectFormat, resolveObjectPromises, resolveRelativePath, runOnce, runParallel, sortAlphabetically, splitTextByLines, verifyIdenticObjectFormat };
+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 };

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

@@ -1,4 +1,16 @@
 //#region src/utils/runOnce.d.ts
+/**
+ * Context handed to the callback so it can interact with the lock it runs under.
+ */
+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
+   * sentinel lives in. Without this, concurrent processes would see no lock and
+   * start a competing run while this one is still writing.
+   */
+  renewLock: () => Promise<void>;
+};
 type RunOnceOptions = {
   /**
    * The function to execute when the sentinel is not found or is older than the cache timeout.
@@ -16,30 +28,42 @@ type RunOnceOptions = {
    * @default false
    */
   forceRun?: boolean;
+  /**
+   * How long to wait for another process to release the sentinel before
+   * considering its run abandoned and taking the lock over.
+   *
+   * @default 300000 = 5 minutes
+   */
+  lockWaitTimeoutMs?: number;
 };
 /**
  * Ensures a callback function runs only once within a specified time window across multiple processes.
  * Uses a sentinel file to coordinate execution and prevent duplicate work.
  *
+ * Processes that lose the race for the sentinel wait for the owner to finish
+ * rather than running a competing copy of the callback — concurrent runs would
+ * otherwise write to (and clean) the same output directory at the same time.
+ *
  * @param sentinelFilePath - Path to the sentinel file used for coordination
  * @param callback - The function to execute (should be async)
  * @param options - The options for the runOnce function
  *
  * @example
  * ```typescript
- * await runPrepareIntlayerOnce(
+ * await runOnce(
  *   '/tmp/intlayer-sentinel',
- *   async () => {
- *     // Your initialization logic here
+ *   async ({ renewLock }) => {
+ *     await cleanOutputDir(configuration); // may delete the sentinel
+ *     await renewLock();
  *     await prepareIntlayer();
  *   },
- *   30 * 1000 // 30 seconds cache
+ *   { cacheTimeoutMs: 30 * 1000 } // 30 seconds cache
  * );
  * ```
  *
  * @throws {Error} When there are unexpected filesystem errors
  */
-declare const runOnce: (sentinelFilePath: string, callback: () => void | Promise<void>, options?: RunOnceOptions) => Promise<void>;
+declare const runOnce: (sentinelFilePath: string, callback: (context: RunOnceContext) => void | Promise<void>, options?: RunOnceOptions) => Promise<void>;
 //#endregion
-export { runOnce };
+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":";KAIK;;;;EAIH,0BAA0B;;;;;;EAM1B;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;cAoEW,UAAO,0BACM,uBACD,eAAa,UAC1B,mBAAc"}
+{"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"}

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/engine",
-  "version": "9.1.3",
+  "version": "9.3.0",
   "private": false,
   "description": "Scans and builds Intlayer declaration files into dictionaries based on Intlayer configuration.",
   "keywords": [
@@ -141,22 +141,22 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "9.1.3",
-    "@intlayer/config": "9.1.3",
-    "@intlayer/core": "9.1.3",
-    "@intlayer/dictionaries-entry": "9.1.3",
-    "@intlayer/remote-dictionaries-entry": "9.1.3",
-    "@intlayer/types": "9.1.3",
-    "@intlayer/unmerged-dictionaries-entry": "9.1.3",
+    "@intlayer/api": "9.3.0",
+    "@intlayer/config": "9.3.0",
+    "@intlayer/core": "9.3.0",
+    "@intlayer/dictionaries-entry": "9.3.0",
+    "@intlayer/remote-dictionaries-entry": "9.3.0",
+    "@intlayer/types": "9.3.0",
+    "@intlayer/unmerged-dictionaries-entry": "9.3.0",
     "@parcel/watcher": "2.6.0",
     "defu": "6.1.7",
     "fast-glob": "3.3.3",
-    "recast": "0.23.14",
+    "recast": "0.23.19",
     "simple-git": "3.36.0",
     "zod-to-ts": "2.1.0"
   },
   "devDependencies": {
-    "@types/node": "26.1.2",
+    "@types/node": "26.2.0",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
@@ -167,7 +167,7 @@
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "@intlayer/babel": "9.1.3"
+    "@intlayer/babel": "9.3.0"
   },
   "peerDependenciesMeta": {
     "@intlayer/babel": {