@moku-labs/web 2.4.11 → 2.4.13

package/dist/browser.d.mts

@@ -1998,6 +1998,12 @@ interface DataState {
   lastWrite: DataWriteSummary | null;
   /** Per-path fetched data, cached after the first `at(path)` (browser). */
   cache: Map<string, unknown>;
+  /**
+   * Per-path fetches still in flight (browser). A second `at(path)` awaits the
+   * same promise instead of starting another request. The entry is removed when
+   * the fetch settles, on success and on failure, so a failure is never cached.
+   */
+  pending: Map<string, Promise<unknown | null>>;
 }
 /**
  * Public API mounted at `app.data` — the agnostic data provider. `write()` is the

package/dist/browser.mjs

@@ -2367,6 +2367,30 @@ async function loadJson(pathOrUrl) {
 * the isomorphic `loadJson` (whose Node branch is itself lazy).
 */
 /**
+* Fetches one path's data, caches it on success, and always clears the path's
+* in-flight entry. Never rejects: a failed fetch or JSON parse resolves `null`
+* and caches nothing, so a later `at(path)` retries.
+*
+* @param ctx - The data plugin context.
+* @param path - The page URL path (e.g. `/en/hello/`).
+* @returns The page's raw data, or `null` on failure.
+* @example
+* ```ts
+* const raw = await fetchAndCache(ctx, "/en/hello/");
+* ```
+*/
+async function fetchAndCache(ctx, path) {
+	try {
+		const data = await loadJson(`${ctx.config.baseUrl}${dataSuffix(path)}`);
+		ctx.state.cache.set(path, data);
+		return data;
+	} catch {
+		return null;
+	} finally {
+		ctx.state.pending.delete(path);
+	}
+}
+/**
 * Builds the data provider — the agnostic bridge. `write()` is the Node persist
 * side; `at()` is the browser read side; `urlFor`/`fileFor` are the pure
 * convention. No `onStart`/`onStop` (holds no long-lived resource).
@@ -2384,6 +2408,7 @@ function dataApi(ctx) {
 	return {
 		/**
 		* READ (browser) — fetch (and cache) the persisted data for a page path.
+		* Concurrent calls for one path share one in-flight request.
 		* Returns the raw JSON as `unknown`, which the route uses directly as `ctx.data`
 		* (no route `.parse()`); returns `null` if the fetch or JSON parse fails (so
 		* `spa` can fall back to HTML).
@@ -2397,13 +2422,11 @@ function dataApi(ctx) {
 		*/
 		async at(path) {
 			if (ctx.state.cache.has(path)) return ctx.state.cache.get(path);
-			try {
-				const data = await loadJson(`${ctx.config.baseUrl}${dataSuffix(path)}`);
-				ctx.state.cache.set(path, data);
-				return data;
-			} catch {
-				return null;
-			}
+			const inFlight = ctx.state.pending.get(path);
+			if (inFlight) return inFlight;
+			const request = fetchAndCache(ctx, path);
+			ctx.state.pending.set(path, request);
+			return request;
 		},
 		/**
 		* WRITE (Node) — persist one JSON file per entry, keyed by page path. Called by
@@ -2472,13 +2495,13 @@ const defaultDataConfig = {
 //#region src/plugins/data/state.ts
 /**
 * Creates initial data state: a null `lastWrite` slot (populated by the Node
-* `write()` side) and an empty `cache` (populated lazily by the browser `at(path)`
-* side on first fetch).
+* `write()` side), an empty `cache` (populated lazily by the browser `at(path)`
+* side on first fetch) and an empty `pending` map of in-flight fetches.
 *
 * @param _ctx - Minimal context with global and config.
 * @param _ctx.global - Global framework configuration.
 * @param _ctx.config - Resolved plugin configuration.
-* @returns Fresh data state with no recorded write and an empty per-path cache.
+* @returns Fresh data state with no recorded write and an empty per-path cache and no pending fetch.
 * @example
 * ```ts
 * const state = createDataState({ global: {}, config });
@@ -2487,7 +2510,8 @@ const defaultDataConfig = {
 function createDataState(_ctx) {
 	return {
 		lastWrite: null,
-		cache: /* @__PURE__ */ new Map()
+		cache: /* @__PURE__ */ new Map(),
+		pending: /* @__PURE__ */ new Map()
 	};
 }
 //#endregion

package/dist/index.cjs

@@ -2299,7 +2299,8 @@ const headPlugin = createPlugin$1("head", {
 /**
 * @file build phase 1 — bundle. Runs `Bun.build` for CSS and JS separately into
 * outDir (honoring `config.minify`) with content-hashed output naming; caches the
-* fingerprinted asset paths for the pages phase and the complete output list for
+* fingerprinted asset paths for the pages phase, the chunks the JS entry imports
+* statically (for `<link rel="modulepreload">`), and the complete output list for
 * the cache-headers phase.
 */
 /** Conventional CSS entry candidates (project-relative). */
@@ -2358,10 +2359,11 @@ const CSS_EXTERNAL_FONT_GLOBS = [
 * @param options.naming.asset - Naming template for additional emitted assets.
 * @param options.external - Import/url() globs left unresolved in the output.
 * @param options.define - Global names replaced with constant expressions.
+* @param options.metafile - Whether to return the build metafile.
 * @returns The structural build result.
 * @example
 * ```ts
-* await defaultRunner({ entrypoints: ["a.css"], outdir: "dist", minify: true, splitting: true, target: "browser", naming: FINGERPRINT_NAMING, external: [], define: {} });
+* await defaultRunner({ entrypoints: ["a.css"], outdir: "dist", minify: true, splitting: true, target: "browser", naming: FINGERPRINT_NAMING, external: [], define: {}, metafile: false });
 * ```
 */
 async function defaultRunner(options) {
@@ -2456,6 +2458,73 @@ function normalizeAssetPath(absolutePath, outDir) {
 	return node_path$1.default.relative(node_path$1.default.resolve(outDir), node_path$1.default.resolve(absolutePath)).split(node_path$1.default.sep).join("/");
 }
 /**
+* Parse the runner's metafile into the structural view (object or JSON string).
+*
+* @param metafile - The metafile as the runner returned it (possibly absent).
+* @returns The parsed metafile, or `undefined` when absent or unreadable.
+* @example
+* ```ts
+* parseMetafile('{"outputs":{}}'); // { outputs: {} }
+* ```
+*/
+function parseMetafile(metafile) {
+	if (typeof metafile !== "string") return metafile;
+	try {
+		return JSON.parse(metafile);
+	} catch {
+		return;
+	}
+}
+/**
+* Normalize an outdir-relative output path into one graph key ("./a.js" and "a.js"
+* are the same file; Windows separators become "/").
+*
+* @param file - An outdir-relative output path.
+* @returns The normalized POSIX key.
+* @example
+* ```ts
+* toKey("./chunk-1.js"); // "chunk-1.js"
+* ```
+*/
+function toKey(file) {
+	return node_path$1.default.posix.normalize(file.split(node_path$1.default.sep).join("/"));
+}
+/**
+* Collect the chunks the JS entry points import STATICALLY, transitively, from the
+* metafile import graph. Only `import-statement` edges are followed: a chunk reached
+* only through a dynamic `import()` stays lazy and is never preloaded. These are the
+* files the browser would otherwise discover only after the entry finished
+* downloading (a request waterfall); the pages phase emits one
+* `<link rel="modulepreload">` per path so they load in parallel with the entry.
+* The walk starts from the `entry-point` artifacts, not from the metafile: Bun also
+* tags each lazy chunk with an `entryPoint`, and a lazy chunk may import the entry.
+*
+* @param result - The JS pass result (artifacts + metafile; no metafile → no preloads).
+* @param outdir - The bundler output directory the metafile paths are relative to.
+* @param outDir - The publish root the web paths are made relative to.
+* @returns The publish-root-relative paths of the static chunks (entries excluded).
+* @example
+* ```ts
+* staticEntryChunks(result, "dist/assets", "dist"); // ["assets/chunk-9f8e.js"]
+* ```
+*/
+function staticEntryChunks(result, outdir, outDir) {
+	const metafile = parseMetafile(result.metafile);
+	if (!metafile) return [];
+	const graph = new Map(Object.entries(metafile.outputs).map(([file, output]) => [toKey(file), (output.imports ?? []).filter((edge) => edge.kind === "import-statement").map((edge) => toKey(edge.path))]));
+	const entries = result.outputs.filter((output) => output.kind === "entry-point" && output.path.endsWith(".js")).map((output) => toKey(node_path$1.default.relative(node_path$1.default.resolve(outdir), node_path$1.default.resolve(output.path))));
+	const seen = new Set(entries);
+	const queue = [...entries];
+	const chunks = [];
+	for (let file = queue.shift(); file !== void 0; file = queue.shift()) for (const target of graph.get(file) ?? []) {
+		if (seen.has(target)) continue;
+		seen.add(target);
+		queue.push(target);
+		chunks.push(normalizeAssetPath(node_path$1.default.join(outdir, target), outDir));
+	}
+	return chunks;
+}
+/**
 * Run one bundler pass for a single asset kind and record the hashed output
 * paths under `state.buildCache` keyed by the original entry basename. Lazy
 * split chunks are emitted to disk but excluded from the recorded manifest
@@ -2484,7 +2553,8 @@ async function runOne(ctx, runner, kind, entrypoints, outDir, outdir, minify, de
 		target: "browser",
 		naming: FINGERPRINT_NAMING,
 		external: kind === "css" ? [...CSS_EXTERNAL_FONT_GLOBS] : [],
-		define
+		define,
+		metafile: kind === "js"
 	});
 	if (!result.success) throw new Error(`[web] build.bundle ${kind} build failed`);
 	const hashed = {};
@@ -2494,6 +2564,7 @@ async function runOne(ctx, runner, kind, entrypoints, outDir, outdir, minify, de
 	}
 	ctx.state.buildCache.set(kind, hashed);
 	ctx.state.buildCache.set(`${kind}:outputs`, result.outputs.map((output) => normalizeAssetPath(output.path, outDir)));
+	if (kind === "js") ctx.state.buildCache.set("js:preload", staticEntryChunks(result, outdir, outDir));
 	ctx.log.debug("build:bundle", {
 		kind,
 		count: result.outputs.length
@@ -2570,6 +2641,22 @@ function readBundleOutputs(ctx, kind) {
 	return Array.isArray(entry) ? entry : [];
 }
 /**
+* Read the chunks the JS entry imports statically (publish-root-relative web paths),
+* recorded by the bundle phase under `js:preload`. Dynamic-import-only chunks are
+* never in this list.
+*
+* @param ctx - Plugin context (provides `state`).
+* @returns The static chunk paths, or an empty array when absent.
+* @example
+* ```ts
+* readPreloads(ctx); // ["assets/chunk-9f8e.js"]
+* ```
+*/
+function readPreloads(ctx) {
+	const entry = ctx.state.buildCache.get("js:preload");
+	return Array.isArray(entry) ? entry : [];
+}
+/**
 * Render the stylesheet `<link>` tags for the fingerprinted CSS manifest.
 *
 * @param ctx - Plugin context (provides `state`).
@@ -2583,17 +2670,23 @@ function buildCssTags(ctx) {
 	return Object.values(readManifest(ctx, "css")).map((href) => `<link rel="stylesheet" href="/${href}">`).join("");
 }
 /**
-* Render the module `<script>` tags for the fingerprinted JS manifest.
+* Render the module `<script>` tags for the fingerprinted JS manifest, followed by
+* one `<link rel="modulepreload">` per chunk the entry imports statically. Without
+* the preloads the browser finds those chunks only after the entry has downloaded
+* and parsed, a request waterfall that delays hydration.
 *
 * @param ctx - Plugin context (provides `state`).
-* @returns The concatenated `<script type="module">` tags (possibly `""`).
+* @returns The concatenated `<script type="module">` and modulepreload tags (possibly `""`).
 * @example
 * ```ts
-* buildJsTags(ctx); // '<script type="module" src="/assets/spa-abc123.js"><\/script>'
+* buildJsTags(ctx);
+* // '<script type="module" src="/assets/spa-abc123.js"><\/script><link rel="modulepreload" href="/assets/chunk-9f8e.js">'
 * ```
 */
 function buildJsTags(ctx) {
-	return Object.values(readManifest(ctx, "js")).map((src) => `<script type="module" src="/${src}"><\/script>`).join("");
+	const scripts = Object.values(readManifest(ctx, "js")).map((src) => `<script type="module" src="/${src}"><\/script>`).join("");
+	if (scripts === "") return "";
+	return scripts + readPreloads(ctx).map((href) => `<link rel="modulepreload" href="/${href}">`).join("");
 }
 /**
 * Build the asset tag block from the fingerprinted manifests — both kinds by
@@ -4532,6 +4625,30 @@ async function loadJson(pathOrUrl) {
 * the isomorphic `loadJson` (whose Node branch is itself lazy).
 */
 /**
+* Fetches one path's data, caches it on success, and always clears the path's
+* in-flight entry. Never rejects: a failed fetch or JSON parse resolves `null`
+* and caches nothing, so a later `at(path)` retries.
+*
+* @param ctx - The data plugin context.
+* @param path - The page URL path (e.g. `/en/hello/`).
+* @returns The page's raw data, or `null` on failure.
+* @example
+* ```ts
+* const raw = await fetchAndCache(ctx, "/en/hello/");
+* ```
+*/
+async function fetchAndCache(ctx, path) {
+	try {
+		const data = await loadJson(`${ctx.config.baseUrl}${require_convention.dataSuffix(path)}`);
+		ctx.state.cache.set(path, data);
+		return data;
+	} catch {
+		return null;
+	} finally {
+		ctx.state.pending.delete(path);
+	}
+}
+/**
 * Builds the data provider — the agnostic bridge. `write()` is the Node persist
 * side; `at()` is the browser read side; `urlFor`/`fileFor` are the pure
 * convention. No `onStart`/`onStop` (holds no long-lived resource).
@@ -4549,6 +4666,7 @@ function dataApi(ctx) {
 	return {
 		/**
 		* READ (browser) — fetch (and cache) the persisted data for a page path.
+		* Concurrent calls for one path share one in-flight request.
 		* Returns the raw JSON as `unknown`, which the route uses directly as `ctx.data`
 		* (no route `.parse()`); returns `null` if the fetch or JSON parse fails (so
 		* `spa` can fall back to HTML).
@@ -4562,13 +4680,11 @@ function dataApi(ctx) {
 		*/
 		async at(path) {
 			if (ctx.state.cache.has(path)) return ctx.state.cache.get(path);
-			try {
-				const data = await loadJson(`${ctx.config.baseUrl}${require_convention.dataSuffix(path)}`);
-				ctx.state.cache.set(path, data);
-				return data;
-			} catch {
-				return null;
-			}
+			const inFlight = ctx.state.pending.get(path);
+			if (inFlight) return inFlight;
+			const request = fetchAndCache(ctx, path);
+			ctx.state.pending.set(path, request);
+			return request;
 		},
 		/**
 		* WRITE (Node) — persist one JSON file per entry, keyed by page path. Called by
@@ -4637,13 +4753,13 @@ const defaultDataConfig = {
 //#region src/plugins/data/state.ts
 /**
 * Creates initial data state: a null `lastWrite` slot (populated by the Node
-* `write()` side) and an empty `cache` (populated lazily by the browser `at(path)`
-* side on first fetch).
+* `write()` side), an empty `cache` (populated lazily by the browser `at(path)`
+* side on first fetch) and an empty `pending` map of in-flight fetches.
 *
 * @param _ctx - Minimal context with global and config.
 * @param _ctx.global - Global framework configuration.
 * @param _ctx.config - Resolved plugin configuration.
-* @returns Fresh data state with no recorded write and an empty per-path cache.
+* @returns Fresh data state with no recorded write and an empty per-path cache and no pending fetch.
 * @example
 * ```ts
 * const state = createDataState({ global: {}, config });
@@ -4652,7 +4768,8 @@ const defaultDataConfig = {
 function createDataState(_ctx) {
 	return {
 		lastWrite: null,
-		cache: /* @__PURE__ */ new Map()
+		cache: /* @__PURE__ */ new Map(),
+		pending: /* @__PURE__ */ new Map()
 	};
 }
 //#endregion

package/dist/index.d.cts

@@ -3467,6 +3467,12 @@ interface DataState {
   lastWrite: DataWriteSummary | null;
   /** Per-path fetched data, cached after the first `at(path)` (browser). */
   cache: Map<string, unknown>;
+  /**
+   * Per-path fetches still in flight (browser). A second `at(path)` awaits the
+   * same promise instead of starting another request. The entry is removed when
+   * the fetch settles, on success and on failure, so a failure is never cached.
+   */
+  pending: Map<string, Promise<unknown | null>>;
 }
 /**
  * Public API mounted at `app.data` — the agnostic data provider. `write()` is the

package/dist/index.d.mts

@@ -3465,6 +3465,12 @@ interface DataState {
   lastWrite: DataWriteSummary | null;
   /** Per-path fetched data, cached after the first `at(path)` (browser). */
   cache: Map<string, unknown>;
+  /**
+   * Per-path fetches still in flight (browser). A second `at(path)` awaits the
+   * same promise instead of starting another request. The entry is removed when
+   * the fetch settles, on success and on failure, so a failure is never cached.
+   */
+  pending: Map<string, Promise<unknown | null>>;
 }
 /**
  * Public API mounted at `app.data` — the agnostic data provider. `write()` is the

package/dist/index.mjs

@@ -2255,7 +2255,8 @@ const headPlugin = createPlugin$1("head", {
 /**
 * @file build phase 1 — bundle. Runs `Bun.build` for CSS and JS separately into
 * outDir (honoring `config.minify`) with content-hashed output naming; caches the
-* fingerprinted asset paths for the pages phase and the complete output list for
+* fingerprinted asset paths for the pages phase, the chunks the JS entry imports
+* statically (for `<link rel="modulepreload">`), and the complete output list for
 * the cache-headers phase.
 */
 /** Conventional CSS entry candidates (project-relative). */
@@ -2314,10 +2315,11 @@ const CSS_EXTERNAL_FONT_GLOBS = [
 * @param options.naming.asset - Naming template for additional emitted assets.
 * @param options.external - Import/url() globs left unresolved in the output.
 * @param options.define - Global names replaced with constant expressions.
+* @param options.metafile - Whether to return the build metafile.
 * @returns The structural build result.
 * @example
 * ```ts
-* await defaultRunner({ entrypoints: ["a.css"], outdir: "dist", minify: true, splitting: true, target: "browser", naming: FINGERPRINT_NAMING, external: [], define: {} });
+* await defaultRunner({ entrypoints: ["a.css"], outdir: "dist", minify: true, splitting: true, target: "browser", naming: FINGERPRINT_NAMING, external: [], define: {}, metafile: false });
 * ```
 */
 async function defaultRunner(options) {
@@ -2412,6 +2414,73 @@ function normalizeAssetPath(absolutePath, outDir) {
 	return path.relative(path.resolve(outDir), path.resolve(absolutePath)).split(path.sep).join("/");
 }
 /**
+* Parse the runner's metafile into the structural view (object or JSON string).
+*
+* @param metafile - The metafile as the runner returned it (possibly absent).
+* @returns The parsed metafile, or `undefined` when absent or unreadable.
+* @example
+* ```ts
+* parseMetafile('{"outputs":{}}'); // { outputs: {} }
+* ```
+*/
+function parseMetafile(metafile) {
+	if (typeof metafile !== "string") return metafile;
+	try {
+		return JSON.parse(metafile);
+	} catch {
+		return;
+	}
+}
+/**
+* Normalize an outdir-relative output path into one graph key ("./a.js" and "a.js"
+* are the same file; Windows separators become "/").
+*
+* @param file - An outdir-relative output path.
+* @returns The normalized POSIX key.
+* @example
+* ```ts
+* toKey("./chunk-1.js"); // "chunk-1.js"
+* ```
+*/
+function toKey(file) {
+	return path.posix.normalize(file.split(path.sep).join("/"));
+}
+/**
+* Collect the chunks the JS entry points import STATICALLY, transitively, from the
+* metafile import graph. Only `import-statement` edges are followed: a chunk reached
+* only through a dynamic `import()` stays lazy and is never preloaded. These are the
+* files the browser would otherwise discover only after the entry finished
+* downloading (a request waterfall); the pages phase emits one
+* `<link rel="modulepreload">` per path so they load in parallel with the entry.
+* The walk starts from the `entry-point` artifacts, not from the metafile: Bun also
+* tags each lazy chunk with an `entryPoint`, and a lazy chunk may import the entry.
+*
+* @param result - The JS pass result (artifacts + metafile; no metafile → no preloads).
+* @param outdir - The bundler output directory the metafile paths are relative to.
+* @param outDir - The publish root the web paths are made relative to.
+* @returns The publish-root-relative paths of the static chunks (entries excluded).
+* @example
+* ```ts
+* staticEntryChunks(result, "dist/assets", "dist"); // ["assets/chunk-9f8e.js"]
+* ```
+*/
+function staticEntryChunks(result, outdir, outDir) {
+	const metafile = parseMetafile(result.metafile);
+	if (!metafile) return [];
+	const graph = new Map(Object.entries(metafile.outputs).map(([file, output]) => [toKey(file), (output.imports ?? []).filter((edge) => edge.kind === "import-statement").map((edge) => toKey(edge.path))]));
+	const entries = result.outputs.filter((output) => output.kind === "entry-point" && output.path.endsWith(".js")).map((output) => toKey(path.relative(path.resolve(outdir), path.resolve(output.path))));
+	const seen = new Set(entries);
+	const queue = [...entries];
+	const chunks = [];
+	for (let file = queue.shift(); file !== void 0; file = queue.shift()) for (const target of graph.get(file) ?? []) {
+		if (seen.has(target)) continue;
+		seen.add(target);
+		queue.push(target);
+		chunks.push(normalizeAssetPath(path.join(outdir, target), outDir));
+	}
+	return chunks;
+}
+/**
 * Run one bundler pass for a single asset kind and record the hashed output
 * paths under `state.buildCache` keyed by the original entry basename. Lazy
 * split chunks are emitted to disk but excluded from the recorded manifest
@@ -2440,7 +2509,8 @@ async function runOne(ctx, runner, kind, entrypoints, outDir, outdir, minify, de
 		target: "browser",
 		naming: FINGERPRINT_NAMING,
 		external: kind === "css" ? [...CSS_EXTERNAL_FONT_GLOBS] : [],
-		define
+		define,
+		metafile: kind === "js"
 	});
 	if (!result.success) throw new Error(`[web] build.bundle ${kind} build failed`);
 	const hashed = {};
@@ -2450,6 +2520,7 @@ async function runOne(ctx, runner, kind, entrypoints, outDir, outdir, minify, de
 	}
 	ctx.state.buildCache.set(kind, hashed);
 	ctx.state.buildCache.set(`${kind}:outputs`, result.outputs.map((output) => normalizeAssetPath(output.path, outDir)));
+	if (kind === "js") ctx.state.buildCache.set("js:preload", staticEntryChunks(result, outdir, outDir));
 	ctx.log.debug("build:bundle", {
 		kind,
 		count: result.outputs.length
@@ -2526,6 +2597,22 @@ function readBundleOutputs(ctx, kind) {
 	return Array.isArray(entry) ? entry : [];
 }
 /**
+* Read the chunks the JS entry imports statically (publish-root-relative web paths),
+* recorded by the bundle phase under `js:preload`. Dynamic-import-only chunks are
+* never in this list.
+*
+* @param ctx - Plugin context (provides `state`).
+* @returns The static chunk paths, or an empty array when absent.
+* @example
+* ```ts
+* readPreloads(ctx); // ["assets/chunk-9f8e.js"]
+* ```
+*/
+function readPreloads(ctx) {
+	const entry = ctx.state.buildCache.get("js:preload");
+	return Array.isArray(entry) ? entry : [];
+}
+/**
 * Render the stylesheet `<link>` tags for the fingerprinted CSS manifest.
 *
 * @param ctx - Plugin context (provides `state`).
@@ -2539,17 +2626,23 @@ function buildCssTags(ctx) {
 	return Object.values(readManifest(ctx, "css")).map((href) => `<link rel="stylesheet" href="/${href}">`).join("");
 }
 /**
-* Render the module `<script>` tags for the fingerprinted JS manifest.
+* Render the module `<script>` tags for the fingerprinted JS manifest, followed by
+* one `<link rel="modulepreload">` per chunk the entry imports statically. Without
+* the preloads the browser finds those chunks only after the entry has downloaded
+* and parsed, a request waterfall that delays hydration.
 *
 * @param ctx - Plugin context (provides `state`).
-* @returns The concatenated `<script type="module">` tags (possibly `""`).
+* @returns The concatenated `<script type="module">` and modulepreload tags (possibly `""`).
 * @example
 * ```ts
-* buildJsTags(ctx); // '<script type="module" src="/assets/spa-abc123.js"><\/script>'
+* buildJsTags(ctx);
+* // '<script type="module" src="/assets/spa-abc123.js"><\/script><link rel="modulepreload" href="/assets/chunk-9f8e.js">'
 * ```
 */
 function buildJsTags(ctx) {
-	return Object.values(readManifest(ctx, "js")).map((src) => `<script type="module" src="/${src}"><\/script>`).join("");
+	const scripts = Object.values(readManifest(ctx, "js")).map((src) => `<script type="module" src="/${src}"><\/script>`).join("");
+	if (scripts === "") return "";
+	return scripts + readPreloads(ctx).map((href) => `<link rel="modulepreload" href="/${href}">`).join("");
 }
 /**
 * Build the asset tag block from the fingerprinted manifests — both kinds by
@@ -4488,6 +4581,30 @@ async function loadJson(pathOrUrl) {
 * the isomorphic `loadJson` (whose Node branch is itself lazy).
 */
 /**
+* Fetches one path's data, caches it on success, and always clears the path's
+* in-flight entry. Never rejects: a failed fetch or JSON parse resolves `null`
+* and caches nothing, so a later `at(path)` retries.
+*
+* @param ctx - The data plugin context.
+* @param path - The page URL path (e.g. `/en/hello/`).
+* @returns The page's raw data, or `null` on failure.
+* @example
+* ```ts
+* const raw = await fetchAndCache(ctx, "/en/hello/");
+* ```
+*/
+async function fetchAndCache(ctx, path) {
+	try {
+		const data = await loadJson(`${ctx.config.baseUrl}${dataSuffix(path)}`);
+		ctx.state.cache.set(path, data);
+		return data;
+	} catch {
+		return null;
+	} finally {
+		ctx.state.pending.delete(path);
+	}
+}
+/**
 * Builds the data provider — the agnostic bridge. `write()` is the Node persist
 * side; `at()` is the browser read side; `urlFor`/`fileFor` are the pure
 * convention. No `onStart`/`onStop` (holds no long-lived resource).
@@ -4505,6 +4622,7 @@ function dataApi(ctx) {
 	return {
 		/**
 		* READ (browser) — fetch (and cache) the persisted data for a page path.
+		* Concurrent calls for one path share one in-flight request.
 		* Returns the raw JSON as `unknown`, which the route uses directly as `ctx.data`
 		* (no route `.parse()`); returns `null` if the fetch or JSON parse fails (so
 		* `spa` can fall back to HTML).
@@ -4518,13 +4636,11 @@ function dataApi(ctx) {
 		*/
 		async at(path) {
 			if (ctx.state.cache.has(path)) return ctx.state.cache.get(path);
-			try {
-				const data = await loadJson(`${ctx.config.baseUrl}${dataSuffix(path)}`);
-				ctx.state.cache.set(path, data);
-				return data;
-			} catch {
-				return null;
-			}
+			const inFlight = ctx.state.pending.get(path);
+			if (inFlight) return inFlight;
+			const request = fetchAndCache(ctx, path);
+			ctx.state.pending.set(path, request);
+			return request;
 		},
 		/**
 		* WRITE (Node) — persist one JSON file per entry, keyed by page path. Called by
@@ -4593,13 +4709,13 @@ const defaultDataConfig = {
 //#region src/plugins/data/state.ts
 /**
 * Creates initial data state: a null `lastWrite` slot (populated by the Node
-* `write()` side) and an empty `cache` (populated lazily by the browser `at(path)`
-* side on first fetch).
+* `write()` side), an empty `cache` (populated lazily by the browser `at(path)`
+* side on first fetch) and an empty `pending` map of in-flight fetches.
 *
 * @param _ctx - Minimal context with global and config.
 * @param _ctx.global - Global framework configuration.
 * @param _ctx.config - Resolved plugin configuration.
-* @returns Fresh data state with no recorded write and an empty per-path cache.
+* @returns Fresh data state with no recorded write and an empty per-path cache and no pending fetch.
 * @example
 * ```ts
 * const state = createDataState({ global: {}, config });
@@ -4608,7 +4724,8 @@ const defaultDataConfig = {
 function createDataState(_ctx) {
 	return {
 		lastWrite: null,
-		cache: /* @__PURE__ */ new Map()
+		cache: /* @__PURE__ */ new Map(),
+		pending: /* @__PURE__ */ new Map()
 	};
 }
 //#endregion

package/package.json

@@ -139,5 +139,5 @@
     "typescript-eslint": "8.58.0",
     "vitest": "4.0.18"
   },
-  "version": "2.4.11"
+  "version": "2.4.13"
 }