@inlang/paraglide-js 2.18.1 → 2.19.0

package/README.md

@@ -11,7 +11,7 @@
 </p>
 
 <p align="center">
-  <a href="https://inlang.com/m/gerre34r/library-inlang-paraglideJs"><strong>Documentation</strong></a> ·
+  <a href="https://paraglidejs.com"><strong>Documentation</strong></a> ·
   <a href="#quick-start"><strong>Quick Start</strong></a> ·
   <a href="https://github.com/opral/inlang-paraglide-js/issues"><strong>Report Bug</strong></a>
 </p>
@@ -26,14 +26,14 @@
   <a href="https://www.michelin.com/"><img src="https://github.com/opral/paraglide-js/blob/main/assets/used-by/michelin.svg?raw=true" alt="Michelin" height="18"></a>&nbsp;&nbsp;&nbsp;
   <a href="https://www.idealista.com/"><img src="https://github.com/opral/paraglide-js/blob/main/assets/used-by/idealista.svg?raw=true" alt="idealista" height="18"></a>&nbsp;&nbsp;&nbsp;
   <a href="https://www.architonic.com/"><img src="https://github.com/opral/paraglide-js/blob/main/assets/used-by/architonic.png?raw=true" alt="Architonic" height="18"></a>&nbsp;&nbsp;&nbsp;
-  <a href="https://www.finanzen100.de/"><img src="https://github.com/opral/paraglide-js/blob/main/assets/used-by/finanzen100.png?raw=true" alt="Finanzen100" height="18"></a>&nbsp;&nbsp;&nbsp;
-  <a href="https://0.email/"><img src="https://github.com/opral/paraglide-js/blob/main/assets/used-by/zero-email.svg?raw=true" alt="0.email" height="18"></a>
+  <a href="https://lovable.dev/"><img src="https://github.com/opral/paraglide-js/blob/main/assets/used-by/lovable.svg?raw=true" alt="Lovable" height="18"></a>&nbsp;&nbsp;&nbsp;
+  <a href="https://www.klaviyo.com/"><img src="https://github.com/opral/paraglide-js/blob/main/assets/used-by/klaviyo.svg?raw=true" alt="Klaviyo" height="18"></a>
 </p>
 
 <p align="center">
   <sub>Framework-authored and framework-tested</sub><br/><br/>
   <a href="https://svelte.dev/docs/cli/paraglide"><img src="https://cdn.simpleicons.org/svelte/FF3E00" alt="Svelte" height="14" /> SvelteKit's official i18n integration</a><br/>
-  <a href="https://inlang.com/blog/tanstack-ci"><img src="https://tanstack.com/images/logos/logo-color-100.png" alt="TanStack" height="14" /> TanStack Router's e2e-tested i18n example</a>
+  <a href="https://paraglidejs.com/blog/tanstack-ci"><img src="https://tanstack.com/images/logos/logo-color-100.png" alt="TanStack" height="14" /> TanStack Router's e2e-tested i18n example</a>
 </p>
 
 ## Code Preview
@@ -51,7 +51,7 @@ import { m } from "./paraglide/messages.js";
 m.greeting({ name: "World" }); // "Hello World!" — fully typesafe
 ```
 
-The compiler turns your messages into typed ESM functions. Vite, Rollup, and other modern bundlers can tree-shake unused translations before they reach the browser. Expect [**up to 70% smaller i18n bundle sizes**](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/benchmark) compared to runtime i18n libraries (e.g. 47 KB vs 205 KB).
+The compiler turns your messages into typed ESM functions. Vite, Rollup, and other modern bundlers can tree-shake unused translations before they reach the browser. Expect [**up to 70% smaller i18n bundle sizes**](https://paraglidejs.com/benchmark) compared to runtime i18n libraries (e.g. 47 KB vs 205 KB).
 
 ## Why Paraglide?
 
@@ -67,23 +67,23 @@ The compiler turns your messages into typed ESM functions. Vite, Rollup, and oth
 ## Get Started With Your Framework
 
 <p>
-  <a href="https://inlang.com/m/gerre34r/library-inlang-paraglideJs/vite"><img src="https://cdn.simpleicons.org/react/61DAFB" alt="React" width="18" height="18" /> React</a> ·
-  <a href="https://inlang.com/m/gerre34r/library-inlang-paraglideJs/vite"><img src="https://cdn.simpleicons.org/vuedotjs/4FC08D" alt="Vue" width="18" height="18" /> Vue</a> ·
+  <a href="https://paraglidejs.com/vite"><img src="https://cdn.simpleicons.org/react/61DAFB" alt="React" width="18" height="18" /> React</a> ·
+  <a href="https://paraglidejs.com/vite"><img src="https://cdn.simpleicons.org/vuedotjs/4FC08D" alt="Vue" width="18" height="18" /> Vue</a> ·
   <a href="https://github.com/TanStack/router/tree/main/examples/react/start-i18n-paraglide"><img src="https://tanstack.com/images/logos/logo-color-100.png" alt="TanStack" width="18" height="18" /> TanStack Start</a> ·
-  <a href="https://inlang.com/m/gerre34r/library-inlang-paraglideJs/sveltekit"><img src="https://cdn.simpleicons.org/svelte/FF3E00" alt="Svelte" width="18" height="18" /> SvelteKit</a> ·
-  <a href="https://inlang.com/m/gerre34r/library-inlang-paraglideJs/react-router"><img src="https://cdn.simpleicons.org/reactrouter/CA4245" alt="React Router" width="18" height="18" /> React Router</a> ·
-  <a href="https://inlang.com/m/gerre34r/library-inlang-paraglideJs/astro"><img src="https://cdn.simpleicons.org/astro/FF5D01" alt="Astro" width="18" height="18" /> Astro</a> ·
-  <a href="https://inlang.com/m/gerre34r/library-inlang-paraglideJs/vanilla-js-ts"><img src="https://cdn.simpleicons.org/javascript/F7DF1E" alt="JavaScript" width="18" height="18" /> Vanilla JS/TS</a>
+  <a href="https://paraglidejs.com/sveltekit"><img src="https://cdn.simpleicons.org/svelte/FF3E00" alt="Svelte" width="18" height="18" /> SvelteKit</a> ·
+  <a href="https://paraglidejs.com/react-router"><img src="https://cdn.simpleicons.org/reactrouter/CA4245" alt="React Router" width="18" height="18" /> React Router</a> ·
+  <a href="https://paraglidejs.com/astro"><img src="https://cdn.simpleicons.org/astro/FF5D01" alt="Astro" width="18" height="18" /> Astro</a> ·
+  <a href="https://paraglidejs.com/vanilla-js-ts"><img src="https://cdn.simpleicons.org/javascript/F7DF1E" alt="JavaScript" width="18" height="18" /> Vanilla JS/TS</a>
 </p>
 
 - **[TanStack Start example](https://github.com/TanStack/router/tree/main/examples/react/start-i18n-paraglide)** — SSR, localized routing, and TanStack Router integration.
-- **[SvelteKit guide](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/sveltekit)** — SvelteKit's official i18n integration.
-- **[React Router guide](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/react-router)** — SSR and client routing.
-- **[Astro guide](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/astro)** — static and server-rendered sites.
-- **[Vite guide](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/vite)** — React, Vue, Solid, or vanilla JS/TS.
+- **[SvelteKit guide](https://paraglidejs.com/sveltekit)** — SvelteKit's official i18n integration.
+- **[React Router guide](https://paraglidejs.com/react-router)** — SSR and client routing.
+- **[Astro guide](https://paraglidejs.com/astro)** — static and server-rendered sites.
+- **[Vite guide](https://paraglidejs.com/vite)** — React, Vue, Solid, or vanilla JS/TS.
 
 > [!TIP]
-> <img src="https://vitejs.dev/logo.svg" alt="Vite" width="16" height="16" /> **Paraglide is ideal for Vite-based apps.** Setup is one plugin, messages compile to ESM, and Vite's tree-shaking eliminates unused translations automatically. [Get started →](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/vite)
+> <img src="https://vitejs.dev/logo.svg" alt="Vite" width="16" height="16" /> **Paraglide is ideal for Vite-based apps.** Setup is one plugin, messages compile to ESM, and Vite's tree-shaking eliminates unused translations automatically. [Get started →](https://paraglidejs.com/vite)
 
 ## SSR Ready
 
@@ -109,7 +109,7 @@ export function handle(request: Request) {
 }
 ```
 
-**[SSR Docs →](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/server-side-rendering)** · **[Middleware Docs →](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/middleware)**
+**[SSR Docs →](https://paraglidejs.com/server-side-rendering)** · **[Middleware Docs →](https://paraglidejs.com/middleware)**
 
 ## Router Composition
 
@@ -129,7 +129,7 @@ localizeUrl("https://example.com/about", { locale: "de" }).href; // https://exam
 
 For routers with rewrite hooks, call `deLocalizeUrl()` on incoming URLs and `localizeUrl()` on outgoing URLs. For file-based routers, keep your file routes canonical and localize at the routing boundary.
 
-**[i18n Routing Docs →](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/i18n-routing)**
+**[i18n Routing Docs →](https://paraglidejs.com/i18n-routing)**
 
 ### TanStack Start
 
@@ -177,7 +177,7 @@ getLocale(); // "en"
 setLocale("de"); // switches to German
 ```
 
-**[Full Getting Started Guide →](https://inlang.com/m/gerre34r/library-inlang-paraglideJs)**
+**[Full Getting Started Guide →](https://paraglidejs.com)**
 
 ## Rich Text
 
@@ -202,7 +202,7 @@ export function ContactCta() {
 
 The markup names come from your message and are type-checked, so translators control where links and emphasis appear while your React app controls how they render.
 
-**[Markup Docs →](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/markup)** · **[React](https://www.npmjs.com/package/@inlang/paraglide-js-react)** · **[Svelte](https://www.npmjs.com/package/@inlang/paraglide-js-svelte)** · **[Vue](https://www.npmjs.com/package/@inlang/paraglide-js-vue)** · **[Solid](https://www.npmjs.com/package/@inlang/paraglide-js-solid)**
+**[Markup Docs →](https://paraglidejs.com/markup)** · **[React](https://www.npmjs.com/package/@inlang/paraglide-js-react)** · **[Svelte](https://www.npmjs.com/package/@inlang/paraglide-js-svelte)** · **[Vue](https://www.npmjs.com/package/@inlang/paraglide-js-vue)** · **[Solid](https://www.npmjs.com/package/@inlang/paraglide-js-solid)**
 
 ## How It Works
 
@@ -248,7 +248,7 @@ m.items_in_cart({ count: 5 }); // "5 items in cart"
 
 Message format is **plugin-based** — use the default inlang format, or switch to i18next, JSON, or ICU MessageFormat via [plugins](https://inlang.com/c/plugins). If your team relies on ICU MessageFormat 1 syntax, use the [inlang-icu-messageformat-1 plugin](https://inlang.com/m/p7c8m1d2/plugin-inlang-icu-messageformat-1).
 
-**[Formatting Docs →](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/formatting)** · **[Pluralization & Variants Docs →](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/variants)**
+**[Formatting Docs →](https://paraglidejs.com/formatting)** · **[Pluralization & Variants Docs →](https://paraglidejs.com/variants)**
 
 ## Why Compiler-First?
 
@@ -256,7 +256,7 @@ Runtime i18n libraries like i18next resolve message keys from dictionaries while
 
 That means Vite can tree-shake unused translations, TypeScript can autocomplete message keys and parameters, and your components call plain functions instead of resolving strings through a runtime lookup layer.
 
-In the [Paraglide benchmark](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/benchmark), typical scenarios shipped **47-144 KB with Paraglide** vs **205-422 KB with i18next**. With 5 locales, 100 used messages, and 200 total messages, Paraglide shipped **47 KB** while i18next shipped **205 KB**.
+In the [Paraglide benchmark](https://paraglidejs.com/benchmark), typical scenarios shipped **47-144 KB with Paraglide** vs **205-422 KB with i18next**. With 5 locales, 100 used messages, and 200 total messages, Paraglide shipped **47 KB** while i18next shipped **205 KB**.
 
 Tree-shaking also keeps Paraglide stable as your message catalog grows. In the benchmark, using 100 messages shipped **47 KB** with Paraglide whether the project had 200, 500, or 1,000 total messages. The i18next runtime bundle grew from **205 KB** to **414 KB**.
 
@@ -273,7 +273,7 @@ Tree-shaking also keeps Paraglide stable as your message catalog grows. In the b
 | **Rich text**           | ✅ Typed markup adapters                                                          | ✅ Rich-text components       | Via framework wrappers |
 | **ICU MessageFormat 1** | ✅ [Via plugin](https://inlang.com/m/p7c8m1d2/plugin-inlang-icu-messageformat-1) | ✅                           | Via plugin           |
 
-**[Full Comparison →](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/comparison)**
+**[Full Comparison →](https://paraglidejs.com/comparison)**
 
 ## FAQ
 
@@ -307,6 +307,12 @@ Yes. Paraglide can compile existing i18next translation files through the [i18ne
 >
 > Daniel · [Why I Replaced i18next with Paraglide JS](https://dropanote.de/en/blog/20250726-why-i-replaced-i18next-with-paraglide-js/)
 
+## Blog Posts
+
+- [Why I Replaced i18next with Paraglide JS](https://dropanote.de/en/blog/20250726-why-i-replaced-i18next-with-paraglide-js/) — A developer's experience reducing bundle size from 40KB to 2KB
+- [react-i18next Was Fine. Then I Found Paraglide.](https://brodin.dev/blog/paraglide-vs-react-i18n) — A developer's experience moving from react-i18next to Paraglide
+- [Inlang / ParaglideJS blew my mind](https://dev.to/robertosnap/inlang-paraglidejs-blew-my-mind-3984) — A developer's first impressions using Paraglide JS with Remix
+
 ## Talks
 
 - [Paraglide JS 1.0 announcement](https://www.youtube.com/watch?v=-YES3CCAG90)
@@ -327,12 +333,12 @@ Paraglide compiles messages from [inlang](https://github.com/opral/inlang), the
 
 ## Documentation
 
-- [Getting Started](https://inlang.com/m/gerre34r/library-inlang-paraglideJs)
-- [Framework Guides](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/react-router) (React Router, SvelteKit, Astro, etc.)
-- [Message Syntax & Pluralization](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/variants)
-- [Formatting (Number/Date/Relative Time)](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/formatting)
-- [Routing & SSR](https://inlang.com/m/gerre34r/library-inlang-paraglideJs/server-side-rendering)
-- [API Reference](https://inlang.com/m/gerre34r/library-inlang-paraglideJs)
+- [Getting Started](https://paraglidejs.com)
+- [Framework Guides](https://paraglidejs.com/react-router) (React Router, SvelteKit, Astro, etc.)
+- [Message Syntax & Pluralization](https://paraglidejs.com/variants)
+- [Formatting (Number/Date/Relative Time)](https://paraglidejs.com/formatting)
+- [Routing & SSR](https://paraglidejs.com/server-side-rendering)
+- [API Reference](https://paraglidejs.com)
 
 ## Contributing
 

package/dist/bundler-plugins/unplugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unplugin.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/unplugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAIhD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAiDvE,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,eAAe,CAqJ3D,CAAC"}
+{"version":3,"file":"unplugin.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/unplugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAMhD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AA8IvE,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,eAAe,CAiN5D,CAAC"}

package/dist/bundler-plugins/unplugin.js

@@ -1,176 +1,284 @@
 import { compile } from "../compiler/compile.js";
-import path, { relative } from "node:path";
+import { relative } from "node:path";
+import { createHash } from "node:crypto";
+import nodeFs from "node:fs";
 import { Logger } from "../services/logger/index.js";
 import { createTrackedFs, getWatchTargets, isPathWithinDirectories, } from "../services/file-watching/tracked-fs.js";
 import { nodeNormalizePath } from "../utilities/node-normalize-path.js";
-import { hashDirectory } from "../services/file-handling/write-output.js";
+import { seedPreviousCompilationFromOutdir } from "../compiler/seed-previous-compilation.js";
 const PLUGIN_NAME = "unplugin-paraglide-js";
 const logger = new Logger();
 /**
  * Default isServer which differs per bundler.
  */
 let isServer;
-let previousCompilation;
-const { fs: trackedFs, readFiles, clearReadFiles } = createTrackedFs();
+// Module-scoped so the warm state survives plugin re-instantiation within
+// one process (e.g. a vite config reload), but recreated when a different
+// fs is passed — the tracked wrapper, read set, and cached compilation are
+// only valid for the filesystem they were produced from.
+let pluginState;
+function getPluginState(args) {
+    if (pluginState === undefined || pluginState.baseFs !== args.fs) {
+        const tracked = createTrackedFs({ fs: args.fs });
+        pluginState = {
+            baseFs: args.fs,
+            trackedFs: tracked.fs,
+            readFiles: tracked.readFiles,
+            clearReadFiles: tracked.clearReadFiles,
+            previousCompilation: undefined,
+            previousInputsDigest: undefined,
+        };
+    }
+    return pluginState;
+}
 function withoutCleanOutdir(args) {
     const { cleanOutdir, ...compileArgs } = args;
     void cleanOutdir;
     return compileArgs;
 }
 /**
- * Seed a synthetic `previousCompilation` from files already on disk in
- * `outdir`. This lets the first compile in a fresh process diff against
- * the prior build's output instead of treating it as empty — so warm
- * restarts produce zero writes and we never wipe `outdir` out from under
- * concurrent readers (SSR/prerender, sibling Vite processes).
+ * Hashes the files (and directory listings) the last compilation read,
+ * together with the options that affect the output. Returns `undefined`
+ * when the digest can't be computed (no tracked reads yet, an unexpected
+ * read error, ...) — `undefined` never matches, so the caller compiles.
  *
- * See https://github.com/opral/inlang-paraglide-js/issues/659.
+ * Directory listings are included so that a message file *added* next to
+ * the tracked ones invalidates the digest, not only edits to known files.
+ * All components are length-prefixed so distinct input states can't
+ * produce the same hash stream.
+ *
+ * The digest is taken after the compile, by re-reading the inputs. A file
+ * edited *during* a compile can therefore be hashed at its new content
+ * while the output reflects the old one — accepted: in dev, watchChange
+ * recompiles on that edit, and a fresh build process always recompiles.
  */
-async function seedPreviousCompilation(outdir, fs) {
-    const absoluteOutdir = path.resolve(process.cwd(), outdir);
-    const resolvedFs = fs ?? (await import("node:fs"));
-    const outputHashes = await hashDirectory(absoluteOutdir, resolvedFs.promises);
-    if (!outputHashes)
+async function computeInputsDigest(state, args, outputStructure) {
+    if (state.readFiles.size === 0) {
         return undefined;
-    return { outputHashes };
-}
-export const unpluginFactory = (args) => ({
-    name: PLUGIN_NAME,
-    enforce: "pre",
-    async buildStart() {
-        const isProduction = process.env.NODE_ENV === "production";
-        // default to locale-modules for development to speed up the dev server
-        // https://github.com/opral/inlang-paraglide-js/issues/486
-        const outputStructure = args.outputStructure ??
-            (isProduction ? "message-modules" : "locale-modules");
-        try {
-            // On a fresh process, seed previousCompilation from on-disk hashes
-            // so the first compile is a no-op when inputs are unchanged. Avoids
-            // racing concurrent readers that wiping outdir would interrupt.
-            const seededPrevious = previousCompilation ??
-                (await seedPreviousCompilation(args.outdir, args.fs));
-            previousCompilation = await compile({
-                fs: trackedFs,
-                previousCompilation: seededPrevious,
-                outputStructure,
-                isServer,
-                ...withoutCleanOutdir(args),
-                cleanOutdir: false,
-            });
-            logger.success(`Compilation complete (${outputStructure})`);
-        }
-        catch (error) {
-            logger.error("Failed to compile project:", error.message);
-            logger.info("Please check your translation files for syntax errors.");
-            if (isProduction)
-                throw error;
-        }
-        finally {
-            // in any case add the files to watch
-            const targets = getWatchTargets(readFiles, { outdir: args.outdir });
-            for (const filePath of targets.files) {
-                this.addWatchFile(filePath);
+    }
+    const targets = getWatchTargets(state.readFiles, { outdir: args.outdir });
+    if (targets.files.size === 0) {
+        return undefined;
+    }
+    const fsp = (args.fs ?? nodeFs).promises;
+    const hash = createHash("sha256");
+    try {
+        const { fs: _fs, ...serializableArgs } = args;
+        void _fs;
+        hash.update(JSON.stringify({ ...serializableArgs, outputStructure, isServer }));
+        for (const directoryPath of [...targets.directories].sort()) {
+            const entries = await fsp
+                .readdir(directoryPath)
+                // tracked reads include probed-but-absent paths (the SDK reads
+                // optional files and handles ENOENT itself) — a missing entry
+                // is valid input state, hash it as such
+                .catch(rethrowUnlessEnoent);
+            hash.update(`\0dir:${directoryPath.length}:${directoryPath}:`);
+            if (entries === undefined) {
+                hash.update("missing");
             }
-            for (const directoryPath of targets.directories) {
-                this.addWatchFile(directoryPath);
+            else {
+                for (const entry of [...entries].sort()) {
+                    hash.update(`${entry.length}:${entry},`);
+                }
             }
         }
-    },
-    async watchChange(path) {
-        const normalizedPath = nodeNormalizePath(path);
-        const targets = getWatchTargets(readFiles, { outdir: args.outdir });
-        if (targets.isIgnoredPath(normalizedPath)) {
-            return;
-        }
-        const shouldCompile = targets.files.has(normalizedPath) ||
-            isPathWithinDirectories(normalizedPath, targets.directories);
-        if (shouldCompile === false) {
-            return;
-        }
-        const isProduction = process.env.NODE_ENV === "production";
-        // default to locale-modules for development to speed up the dev server
-        // https://github.com/opral/inlang-paraglide-js/issues/486
-        const outputStructure = args.outputStructure ??
-            (isProduction ? "message-modules" : "locale-modules");
-        const previouslyReadFiles = new Set(readFiles);
-        try {
-            logger.info(`Re-compiling inlang project... File "${relative(process.cwd(), path)}" has changed.`);
-            // Clear readFiles to track fresh file reads
-            clearReadFiles();
-            previousCompilation = await compile({
-                fs: trackedFs,
-                previousCompilation,
-                outputStructure,
-                isServer,
-                ...withoutCleanOutdir(args),
-                cleanOutdir: false,
-            });
-            logger.success(`Re-compilation complete (${outputStructure})`);
-            // Add any new files to watch
-            const nextTargets = getWatchTargets(readFiles, { outdir: args.outdir });
-            for (const filePath of nextTargets.files) {
-                this.addWatchFile(filePath);
+        for (const filePath of [...targets.files].sort()) {
+            const content = await fsp.readFile(filePath).catch(rethrowUnlessEnoent);
+            hash.update(`\0file:${filePath.length}:${filePath}:`);
+            if (content === undefined) {
+                hash.update("missing");
             }
-            for (const directoryPath of nextTargets.directories) {
-                this.addWatchFile(directoryPath);
+            else {
+                hash.update(`${content.length}:`);
+                hash.update(content);
             }
         }
-        catch (e) {
-            clearReadFiles();
-            for (const filePath of previouslyReadFiles) {
-                readFiles.add(filePath);
-            }
-            // Reset compilation result on error
-            previousCompilation = undefined;
-            logger.warn("Failed to re-compile project:", e.message);
-        }
-    },
-    vite: {
-        config: {
-            handler: () => {
-                isServer = "import.meta.env?.SSR ?? typeof window === 'undefined'";
-            },
-        },
-        configEnvironment: {
-            handler: () => {
-                isServer = "import.meta.env?.SSR ?? typeof window === 'undefined'";
-            },
-        },
-    },
-    webpack(compiler) {
-        compiler.options.resolve = {
-            ...compiler.options.resolve,
-            fallback: {
-                ...compiler.options.resolve?.fallback,
-                // https://stackoverflow.com/a/72989932
-                async_hooks: false,
-            },
-        };
-        compiler.hooks.beforeRun.tapPromise(PLUGIN_NAME, async () => {
+    }
+    catch {
+        return undefined;
+    }
+    return hash.digest("hex");
+}
+function rethrowUnlessEnoent(error) {
+    if (error?.code === "ENOENT") {
+        return undefined;
+    }
+    throw error;
+}
+export const unpluginFactory = (args) => {
+    const state = getPluginState(args);
+    const { trackedFs, readFiles, clearReadFiles } = state;
+    return {
+        name: PLUGIN_NAME,
+        enforce: "pre",
+        async buildStart() {
             const isProduction = process.env.NODE_ENV === "production";
             // default to locale-modules for development to speed up the dev server
             // https://github.com/opral/inlang-paraglide-js/issues/486
             const outputStructure = args.outputStructure ??
                 (isProduction ? "message-modules" : "locale-modules");
             try {
-                const seededPrevious = previousCompilation ??
-                    (await seedPreviousCompilation(args.outdir, args.fs));
-                previousCompilation = await compile({
-                    fs: trackedFs,
+                // `vite build` calls buildStart once per environment (client, ssr).
+                // Skip the expensive compile when the inputs haven't changed.
+                if (state.previousCompilation && state.previousInputsDigest) {
+                    const currentDigest = await computeInputsDigest(state, args, outputStructure);
+                    if (currentDigest === state.previousInputsDigest) {
+                        logger.info(`Compilation skipped — inputs unchanged (${outputStructure})`);
+                        return;
+                    }
+                }
+                // On a fresh process, seed previousCompilation from on-disk hashes
+                // so the first compile is a no-op when inputs are unchanged. Avoids
+                // racing concurrent readers that wiping outdir would interrupt.
+                const seededPrevious = state.previousCompilation ??
+                    (await seedPreviousCompilationFromOutdir({
+                        outdir: args.outdir,
+                        fs: args.fs?.promises,
+                    }));
+                state.previousCompilation = await compile({
                     previousCompilation: seededPrevious,
                     outputStructure,
+                    isServer,
                     ...withoutCleanOutdir(args),
                     cleanOutdir: false,
+                    // after the args spread so a user-provided fs doesn't bypass
+                    // the read tracking (trackedFs wraps args.fs when provided)
+                    fs: trackedFs,
                 });
+                state.previousInputsDigest = await computeInputsDigest(state, args, outputStructure);
                 logger.success(`Compilation complete (${outputStructure})`);
             }
             catch (error) {
-                logger.warn("Failed to compile project:", error.message);
-                logger.warn("Please check your translation files for syntax errors.");
+                state.previousInputsDigest = undefined;
+                logger.error("Failed to compile project:", error.message);
+                logger.info("Please check your translation files for syntax errors.");
                 if (isProduction)
                     throw error;
             }
-        });
-    },
-});
+            finally {
+                // in any case add the files to watch
+                const targets = getWatchTargets(readFiles, { outdir: args.outdir });
+                for (const filePath of targets.files) {
+                    this.addWatchFile(filePath);
+                }
+                for (const directoryPath of targets.directories) {
+                    this.addWatchFile(directoryPath);
+                }
+            }
+        },
+        async watchChange(path) {
+            const normalizedPath = nodeNormalizePath(path);
+            const targets = getWatchTargets(readFiles, { outdir: args.outdir });
+            if (targets.isIgnoredPath(normalizedPath)) {
+                return;
+            }
+            const shouldCompile = targets.files.has(normalizedPath) ||
+                isPathWithinDirectories(normalizedPath, targets.directories);
+            if (shouldCompile === false) {
+                return;
+            }
+            const isProduction = process.env.NODE_ENV === "production";
+            // default to locale-modules for development to speed up the dev server
+            // https://github.com/opral/inlang-paraglide-js/issues/486
+            const outputStructure = args.outputStructure ??
+                (isProduction ? "message-modules" : "locale-modules");
+            const previouslyReadFiles = new Set(readFiles);
+            try {
+                logger.info(`Re-compiling inlang project... File "${relative(process.cwd(), path)}" has changed.`);
+                // Clear readFiles to track fresh file reads
+                clearReadFiles();
+                state.previousCompilation = await compile({
+                    previousCompilation: state.previousCompilation,
+                    outputStructure,
+                    isServer,
+                    ...withoutCleanOutdir(args),
+                    cleanOutdir: false,
+                    fs: trackedFs,
+                });
+                state.previousInputsDigest = await computeInputsDigest(state, args, outputStructure);
+                logger.success(`Re-compilation complete (${outputStructure})`);
+                // Add any new files to watch
+                const nextTargets = getWatchTargets(readFiles, { outdir: args.outdir });
+                for (const filePath of nextTargets.files) {
+                    this.addWatchFile(filePath);
+                }
+                for (const directoryPath of nextTargets.directories) {
+                    this.addWatchFile(directoryPath);
+                }
+            }
+            catch (e) {
+                clearReadFiles();
+                for (const filePath of previouslyReadFiles) {
+                    readFiles.add(filePath);
+                }
+                // Reset compilation result on error
+                state.previousCompilation = undefined;
+                state.previousInputsDigest = undefined;
+                logger.warn("Failed to re-compile project:", e.message);
+            }
+        },
+        vite: {
+            config: {
+                handler: () => {
+                    isServer = "import.meta.env?.SSR ?? typeof window === 'undefined'";
+                },
+            },
+            configEnvironment: {
+                handler: () => {
+                    isServer = "import.meta.env?.SSR ?? typeof window === 'undefined'";
+                },
+            },
+        },
+        webpack(compiler) {
+            compiler.options.resolve = {
+                ...compiler.options.resolve,
+                fallback: {
+                    ...compiler.options.resolve?.fallback,
+                    // https://stackoverflow.com/a/72989932
+                    async_hooks: false,
+                },
+            };
+            compiler.hooks.beforeRun.tapPromise(PLUGIN_NAME, async () => {
+                const isProduction = process.env.NODE_ENV === "production";
+                // default to locale-modules for development to speed up the dev server
+                // https://github.com/opral/inlang-paraglide-js/issues/486
+                const outputStructure = args.outputStructure ??
+                    (isProduction ? "message-modules" : "locale-modules");
+                try {
+                    // Multi-compiler webpack setups (client + server) trigger
+                    // beforeRun once per compiler — skip when inputs are unchanged.
+                    if (state.previousCompilation && state.previousInputsDigest) {
+                        const currentDigest = await computeInputsDigest(state, args, outputStructure);
+                        if (currentDigest === state.previousInputsDigest) {
+                            logger.info(`Compilation skipped — inputs unchanged (${outputStructure})`);
+                            return;
+                        }
+                    }
+                    const seededPrevious = state.previousCompilation ??
+                        (await seedPreviousCompilationFromOutdir({
+                            outdir: args.outdir,
+                            fs: args.fs?.promises,
+                        }));
+                    state.previousCompilation = await compile({
+                        previousCompilation: seededPrevious,
+                        outputStructure,
+                        ...withoutCleanOutdir(args),
+                        cleanOutdir: false,
+                        fs: trackedFs,
+                    });
+                    state.previousInputsDigest = await computeInputsDigest(state, args, outputStructure);
+                    logger.success(`Compilation complete (${outputStructure})`);
+                }
+                catch (error) {
+                    state.previousInputsDigest = undefined;
+                    logger.warn("Failed to compile project:", error.message);
+                    logger.warn("Please check your translation files for syntax errors.");
+                    if (isProduction)
+                        throw error;
+                }
+            });
+        },
+    };
+};
 //# sourceMappingURL=unplugin.js.map