@intlayer/engine 9.5.11 → 9.5.12

package/dist/types/cli.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/types/prepareIntlayerServer.d.ts

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

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

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

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

@@ -0,0 +1,35 @@
+//#region src/utils/getProcessChainCommands.d.ts
+/** Process as listed by the OS: its parent and the command line it runs. */
+export type ProcessEntry = {
+  parentPid: number;
+  command: string;
+};
+/**
+ * Parses the output of `ps -A -o pid=,ppid=,command=`.
+ *
+ * @param output - One `<pid> <ppid> <command>` row per line.
+ * @returns The processes, keyed by PID.
+ */
+export declare const parseProcessTable: (output: string) => Map<number, ProcessEntry>;
+/**
+ * Command lines of this process and of the processes above it, closest first.
+ *
+ * This process is included because some runtimes restart the script inside
+ * the same process, leaving their watch flag only on their own command line
+ * (`deno run --watch`).
+ *
+ * Best effort: resolves to an empty list on Windows, or when the process list
+ * cannot be read (sandbox, missing `ps`, Deno without the permission), and
+ * never throws.
+ *
+ * @param maxDepth - How many processes to read at most, this one included.
+ *
+ * @example
+ * ```ts
+ * await getProcessChainCommands();
+ * // → ['node src/index.js', 'node …/nodemon src/index.js', 'npm run dev']
+ * ```
+ */
+export declare const getProcessChainCommands: (maxDepth?: number) => Promise<string[]>;
+//#endregion
+//# sourceMappingURL=getProcessChainCommands.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getProcessChainCommands.d.ts","names":[],"sources":["../../../src/utils/getProcessChainCommands.ts"],"mappings":";;YAKY;EACV;EACA;;;;;;;;qBAYW,oBAAiB,mBAE3B,YAAY;;;;;;;;;;;;;;;;;;;;qBA2GF,0BAAuB,sBAEjC"}

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

@@ -20,6 +20,7 @@ import { RunOnceContext, runOnce } from "./runOnce.js";
 import { ParallelHandle, runParallel } from "./runParallel/index.js";
 import { sortAlphabetically } from "./sortAlphabetically.js";
 import { splitTextByLines } from "./splitTextByLine.js";
+import { StartContentWatcherOptions, startContentWatcher } from "./startContentWatcher.js";
 import { verifyIdenticObjectFormat } from "./verifyIdenticObjectFormat.js";
 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 };
+export { CLI_CONTENT_WATCHER_ENV_VAR, ContentDeclarationFileName, ContentWatcherOwner, ContentWatcherSource, Extension, Format, JSONObject, JsonChunk, ParallelHandle, Primitive, Queue, Recursive, RunOnceContext, StartContentWatcherOptions, 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, startContentWatcher, verifyIdenticObjectFormat, withFileLock };

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

@@ -0,0 +1,40 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+//#region src/utils/startContentWatcher.d.ts
+export type StartContentWatcherOptions = {
+  /**
+   * How the integration names itself in the lock and in messages, e.g.
+   * `vite-intlayer`.
+   */
+  label: string;
+  /**
+   * Whether this process must never own the watcher, re-checked on every
+   * attempt (e.g. a helper process that outlives the dev server).
+   */
+  getShouldSkip?: () => boolean;
+};
+/**
+ * Starts the content declaration watcher from an integration (bundler plugin or
+ * server middleware), making sure only one watcher rebuilds a project's
+ * dictionaries.
+ *
+ * - Idempotent within a process, across module copies and hot reloads.
+ * - Stands down, with an explanation, when `intlayer watch` already covers the
+ *   project, whether it spawned this process (`--with`) or runs elsewhere.
+ * - Otherwise the first process to take the project lock watches; the others
+ *   retry in the background to take over once it stops.
+ *
+ * Not awaitable on purpose: a dev server must not wait on the watcher to serve.
+ *
+ * @param configuration - The resolved Intlayer configuration.
+ * @param options - How the integration identifies itself.
+ *
+ * @example
+ * ```ts
+ * configureServer() {
+ *   startContentWatcher(configuration, { label: 'vite-intlayer' });
+ * }
+ * ```
+ */
+export declare const startContentWatcher: (configuration: IntlayerConfig, options: StartContentWatcherOptions) => void;
+//#endregion
+//# sourceMappingURL=startContentWatcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"startContentWatcher.d.ts","names":[],"sources":["../../../src/utils/startContentWatcher.ts"],"mappings":";;YAgBY;;;;;EAKV;;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;;;;qBA6GW,sBAAmB,eACf,gBAAc,SACpB"}

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"watcher.d.ts","names":[],"sources":["../../src/watcher.ts"],"mappings":";;;KA0DK;EACH,gBAAgB;EAChB,gBAAgB;EAChB;EACA;;qBAsBW,QAAK,UAAoB,iBAAY;EAkDZ,mBAAM;;qBAgR/B,wBAAqB,UAAoB,iBAAY"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/engine",
-  "version": "9.5.11",
+  "version": "9.5.12",
   "private": false,
   "description": "Scans and builds Intlayer declaration files into dictionaries based on Intlayer configuration.",
   "keywords": [
@@ -150,11 +150,11 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "9.5.11",
-    "@intlayer/config": "9.5.11",
-    "@intlayer/core": "9.5.11",
-    "@intlayer/dictionaries-entry": "9.5.11",
-    "@intlayer/types": "9.5.11",
+    "@intlayer/api": "9.5.12",
+    "@intlayer/config": "9.5.12",
+    "@intlayer/core": "9.5.12",
+    "@intlayer/dictionaries-entry": "9.5.12",
+    "@intlayer/types": "9.5.12",
     "@parcel/watcher": "2.6.0",
     "defu": "6.1.7",
     "fast-glob": "3.3.3",
@@ -174,7 +174,7 @@
     "zod": "4.6.5"
   },
   "peerDependencies": {
-    "@intlayer/babel": "9.5.11"
+    "@intlayer/babel": "9.5.12"
   },
   "peerDependenciesMeta": {
     "@intlayer/babel": {

package/dist/cjs/init/utils/devScript.cjs

@@ -1,57 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-//#region src/init/utils/devScript.ts
-/**
-* Frameworks with no Intlayer bundler plugin to host the content watcher.
-*
-* Their dev server is a plain Node process, so the only way to rebuild
-* `.intlayer` on a content change is to run the watcher next to it.
-*/
-const BACKEND_INTLAYER_PACKAGES = [
-	"express-intlayer",
-	"fastify-intlayer",
-	"adonis-intlayer",
-	"hono-intlayer",
-	"elysia-intlayer",
-	"remix-intlayer"
-];
-/**
-* Resolves the `dev` script `intlayer init` should write, or `null` when the
-* project's script must be left alone.
-*
-* A Next.js app is always left alone: `withIntlayer` starts the content watcher
-* itself on both bundlers, so wrapping the dev server in `intlayer watch --with`
-* would only add a second watcher rebuilding the same dictionaries. This is checked on the
-* `next` dependency as well as on the config file, since `next.config.*` is
-* optional, and it takes precedence over the backend list, which a Next.js app
-* with a custom server (or a monorepo root) can match too.
-*
-* @example a backend project gets its dev server wrapped
-* ```ts
-* resolveDevScript({
-*   devScript: 'node ./src/index.ts',
-*   allDeps: { 'express-intlayer': '9.0.0' },
-*   isNextJsProject: false,
-* }); // → "intlayer watch --with 'node ./src/index.ts'"
-* ```
-*
-* @example a Next.js project keeps its own script
-* ```ts
-* resolveDevScript({
-*   devScript: 'next dev',
-*   allDeps: { next: '16.0.0' },
-*   isNextJsProject: true,
-* }); // → null
-* ```
-*/
-const resolveDevScript = ({ devScript, allDeps, isNextJsProject }) => {
-	if (!devScript) return null;
-	if (isNextJsProject || Boolean(allDeps.next)) return null;
-	if (!BACKEND_INTLAYER_PACKAGES.some((packageName) => allDeps[packageName])) return null;
-	if (devScript.includes("intlayer watch")) return null;
-	return `intlayer watch --with '${devScript}'`;
-};
-
-//#endregion
-exports.BACKEND_INTLAYER_PACKAGES = BACKEND_INTLAYER_PACKAGES;
-exports.resolveDevScript = resolveDevScript;
-//# sourceMappingURL=devScript.cjs.map

package/dist/cjs/init/utils/devScript.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"devScript.cjs","names":[],"sources":["../../../../src/init/utils/devScript.ts"],"sourcesContent":["/**\n * Frameworks with no Intlayer bundler plugin to host the content watcher.\n *\n * Their dev server is a plain Node process, so the only way to rebuild\n * `.intlayer` on a content change is to run the watcher next to it.\n */\nexport const BACKEND_INTLAYER_PACKAGES = [\n  'express-intlayer',\n  'fastify-intlayer',\n  'adonis-intlayer',\n  'hono-intlayer',\n  'elysia-intlayer',\n  'remix-intlayer',\n];\n\nexport type ResolveDevScriptParams = {\n  /** The project's current `dev` script, if it has one. */\n  devScript?: string;\n  /** Combined prod + dev dependencies of the project. */\n  allDeps: Record<string, string>;\n  /** Whether a `next.config.*` file was found in the project. */\n  isNextJsProject: boolean;\n};\n\n/**\n * Resolves the `dev` script `intlayer init` should write, or `null` when the\n * project's script must be left alone.\n *\n * A Next.js app is always left alone: `withIntlayer` starts the content watcher\n * itself on both bundlers, so wrapping the dev server in `intlayer watch --with`\n * would only add a second watcher rebuilding the same dictionaries. This is checked on the\n * `next` dependency as well as on the config file, since `next.config.*` is\n * optional, and it takes precedence over the backend list, which a Next.js app\n * with a custom server (or a monorepo root) can match too.\n *\n * @example a backend project gets its dev server wrapped\n * ```ts\n * resolveDevScript({\n *   devScript: 'node ./src/index.ts',\n *   allDeps: { 'express-intlayer': '9.0.0' },\n *   isNextJsProject: false,\n * }); // → \"intlayer watch --with 'node ./src/index.ts'\"\n * ```\n *\n * @example a Next.js project keeps its own script\n * ```ts\n * resolveDevScript({\n *   devScript: 'next dev',\n *   allDeps: { next: '16.0.0' },\n *   isNextJsProject: true,\n * }); // → null\n * ```\n */\nexport const resolveDevScript = ({\n  devScript,\n  allDeps,\n  isNextJsProject,\n}: ResolveDevScriptParams): string | null => {\n  if (!devScript) return null;\n\n  const isNextJsApp = isNextJsProject || Boolean(allDeps.next);\n\n  if (isNextJsApp) return null;\n\n  const hasBackendIntlayerPackage = BACKEND_INTLAYER_PACKAGES.some(\n    (packageName) => allDeps[packageName]\n  );\n\n  if (!hasBackendIntlayerPackage) return null;\n\n  // Re-running init must not nest one wrapper inside another.\n  if (devScript.includes('intlayer watch')) return null;\n\n  return `intlayer watch --with '${devScript}'`;\n};\n"],"mappings":";;;;;;;;AAMA,MAAa,4BAA4B;CACvC;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,MAAa,oBAAoB,EAC/B,WACA,SACA,sBAC2C;CAC3C,IAAI,CAAC,WAAW,OAAO;CAIvB,IAFoB,mBAAmB,QAAQ,QAAQ,IAAI,GAE1C,OAAO;CAMxB,IAAI,CAJ8B,0BAA0B,MACzD,gBAAgB,QAAQ,YAGE,GAAG,OAAO;CAGvC,IAAI,UAAU,SAAS,gBAAgB,GAAG,OAAO;CAEjD,OAAO,0BAA0B,UAAU;AAC7C"}

package/dist/esm/init/utils/devScript.mjs

@@ -1,55 +0,0 @@
-//#region src/init/utils/devScript.ts
-/**
-* Frameworks with no Intlayer bundler plugin to host the content watcher.
-*
-* Their dev server is a plain Node process, so the only way to rebuild
-* `.intlayer` on a content change is to run the watcher next to it.
-*/
-const BACKEND_INTLAYER_PACKAGES = [
-	"express-intlayer",
-	"fastify-intlayer",
-	"adonis-intlayer",
-	"hono-intlayer",
-	"elysia-intlayer",
-	"remix-intlayer"
-];
-/**
-* Resolves the `dev` script `intlayer init` should write, or `null` when the
-* project's script must be left alone.
-*
-* A Next.js app is always left alone: `withIntlayer` starts the content watcher
-* itself on both bundlers, so wrapping the dev server in `intlayer watch --with`
-* would only add a second watcher rebuilding the same dictionaries. This is checked on the
-* `next` dependency as well as on the config file, since `next.config.*` is
-* optional, and it takes precedence over the backend list, which a Next.js app
-* with a custom server (or a monorepo root) can match too.
-*
-* @example a backend project gets its dev server wrapped
-* ```ts
-* resolveDevScript({
-*   devScript: 'node ./src/index.ts',
-*   allDeps: { 'express-intlayer': '9.0.0' },
-*   isNextJsProject: false,
-* }); // → "intlayer watch --with 'node ./src/index.ts'"
-* ```
-*
-* @example a Next.js project keeps its own script
-* ```ts
-* resolveDevScript({
-*   devScript: 'next dev',
-*   allDeps: { next: '16.0.0' },
-*   isNextJsProject: true,
-* }); // → null
-* ```
-*/
-const resolveDevScript = ({ devScript, allDeps, isNextJsProject }) => {
-	if (!devScript) return null;
-	if (isNextJsProject || Boolean(allDeps.next)) return null;
-	if (!BACKEND_INTLAYER_PACKAGES.some((packageName) => allDeps[packageName])) return null;
-	if (devScript.includes("intlayer watch")) return null;
-	return `intlayer watch --with '${devScript}'`;
-};
-
-//#endregion
-export { BACKEND_INTLAYER_PACKAGES, resolveDevScript };
-//# sourceMappingURL=devScript.mjs.map

package/dist/esm/init/utils/devScript.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"devScript.mjs","names":[],"sources":["../../../../src/init/utils/devScript.ts"],"sourcesContent":["/**\n * Frameworks with no Intlayer bundler plugin to host the content watcher.\n *\n * Their dev server is a plain Node process, so the only way to rebuild\n * `.intlayer` on a content change is to run the watcher next to it.\n */\nexport const BACKEND_INTLAYER_PACKAGES = [\n  'express-intlayer',\n  'fastify-intlayer',\n  'adonis-intlayer',\n  'hono-intlayer',\n  'elysia-intlayer',\n  'remix-intlayer',\n];\n\nexport type ResolveDevScriptParams = {\n  /** The project's current `dev` script, if it has one. */\n  devScript?: string;\n  /** Combined prod + dev dependencies of the project. */\n  allDeps: Record<string, string>;\n  /** Whether a `next.config.*` file was found in the project. */\n  isNextJsProject: boolean;\n};\n\n/**\n * Resolves the `dev` script `intlayer init` should write, or `null` when the\n * project's script must be left alone.\n *\n * A Next.js app is always left alone: `withIntlayer` starts the content watcher\n * itself on both bundlers, so wrapping the dev server in `intlayer watch --with`\n * would only add a second watcher rebuilding the same dictionaries. This is checked on the\n * `next` dependency as well as on the config file, since `next.config.*` is\n * optional, and it takes precedence over the backend list, which a Next.js app\n * with a custom server (or a monorepo root) can match too.\n *\n * @example a backend project gets its dev server wrapped\n * ```ts\n * resolveDevScript({\n *   devScript: 'node ./src/index.ts',\n *   allDeps: { 'express-intlayer': '9.0.0' },\n *   isNextJsProject: false,\n * }); // → \"intlayer watch --with 'node ./src/index.ts'\"\n * ```\n *\n * @example a Next.js project keeps its own script\n * ```ts\n * resolveDevScript({\n *   devScript: 'next dev',\n *   allDeps: { next: '16.0.0' },\n *   isNextJsProject: true,\n * }); // → null\n * ```\n */\nexport const resolveDevScript = ({\n  devScript,\n  allDeps,\n  isNextJsProject,\n}: ResolveDevScriptParams): string | null => {\n  if (!devScript) return null;\n\n  const isNextJsApp = isNextJsProject || Boolean(allDeps.next);\n\n  if (isNextJsApp) return null;\n\n  const hasBackendIntlayerPackage = BACKEND_INTLAYER_PACKAGES.some(\n    (packageName) => allDeps[packageName]\n  );\n\n  if (!hasBackendIntlayerPackage) return null;\n\n  // Re-running init must not nest one wrapper inside another.\n  if (devScript.includes('intlayer watch')) return null;\n\n  return `intlayer watch --with '${devScript}'`;\n};\n"],"mappings":";;;;;;;AAMA,MAAa,4BAA4B;CACvC;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,MAAa,oBAAoB,EAC/B,WACA,SACA,sBAC2C;CAC3C,IAAI,CAAC,WAAW,OAAO;CAIvB,IAFoB,mBAAmB,QAAQ,QAAQ,IAAI,GAE1C,OAAO;CAMxB,IAAI,CAJ8B,0BAA0B,MACzD,gBAAgB,QAAQ,YAGE,GAAG,OAAO;CAGvC,IAAI,UAAU,SAAS,gBAAgB,GAAG,OAAO;CAEjD,OAAO,0BAA0B,UAAU;AAC7C"}

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

@@ -1,48 +0,0 @@
-//#region src/init/utils/devScript.d.ts
-/**
- * Frameworks with no Intlayer bundler plugin to host the content watcher.
- *
- * Their dev server is a plain Node process, so the only way to rebuild
- * `.intlayer` on a content change is to run the watcher next to it.
- */
-export declare const BACKEND_INTLAYER_PACKAGES: string[];
-export type ResolveDevScriptParams = {
-  /** The project's current `dev` script, if it has one. */
-  devScript?: string;
-  /** Combined prod + dev dependencies of the project. */
-  allDeps: Record<string, string>;
-  /** Whether a `next.config.*` file was found in the project. */
-  isNextJsProject: boolean;
-};
-/**
- * Resolves the `dev` script `intlayer init` should write, or `null` when the
- * project's script must be left alone.
- *
- * A Next.js app is always left alone: `withIntlayer` starts the content watcher
- * itself on both bundlers, so wrapping the dev server in `intlayer watch --with`
- * would only add a second watcher rebuilding the same dictionaries. This is checked on the
- * `next` dependency as well as on the config file, since `next.config.*` is
- * optional, and it takes precedence over the backend list, which a Next.js app
- * with a custom server (or a monorepo root) can match too.
- *
- * @example a backend project gets its dev server wrapped
- * ```ts
- * resolveDevScript({
- *   devScript: 'node ./src/index.ts',
- *   allDeps: { 'express-intlayer': '9.0.0' },
- *   isNextJsProject: false,
- * }); // → "intlayer watch --with 'node ./src/index.ts'"
- * ```
- *
- * @example a Next.js project keeps its own script
- * ```ts
- * resolveDevScript({
- *   devScript: 'next dev',
- *   allDeps: { next: '16.0.0' },
- *   isNextJsProject: true,
- * }); // → null
- * ```
- */
-export declare const resolveDevScript: ({ devScript, allDeps, isNextJsProject }: ResolveDevScriptParams) => string | null;
-//#endregion
-//# sourceMappingURL=devScript.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"devScript.d.ts","names":[],"sources":["../../../../src/init/utils/devScript.ts"],"mappings":";;;;;;;qBAMa;YASD;;EAEV;;EAEA,SAAS;;EAET;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgCW,qBAAgB,WAAA,SAAA,mBAI1B"}