@trackunit/iris-app-sdk-vite 0.4.3 → 0.4.5

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.4.5 (2026-04-30)
+
+### 🧱 Updated Dependencies
+
+- Updated iris-app-build-utilities to 1.16.4
+- Updated iris-app-api to 1.18.3
+- Updated iris-app to 1.19.4
+
+## 0.4.4 (2026-04-30)
+
+This was a version bump only for iris-app-sdk-vite to align it with other projects, there were no code changes.
+
 ## 0.4.3 (2026-04-30)
 
 ### 🧱 Updated Dependencies

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/iris-app-sdk-vite",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "license": "SEE LICENSE IN LICENSE.txt",
   "repository": "https://github.com/Trackunit/manager",
   "executors": "./executors.json",
@@ -10,8 +10,8 @@
   "dependencies": {
     "rxjs": "7.8.1",
     "win-ca": "^3.5.1",
-    "@trackunit/iris-app-build-utilities": "1.16.3",
-    "@trackunit/iris-app-api": "1.18.2",
+    "@trackunit/iris-app-build-utilities": "1.16.4",
+    "@trackunit/iris-app-api": "1.18.3",
     "tslib": "^2.6.2",
     "vite": "7.3.1",
     "@module-federation/vite": "1.11.0",
@@ -22,7 +22,7 @@
     "@tailwindcss/postcss": "^4.1.18",
     "@vitejs/plugin-react-swc": "^4.2.3",
     "@nx/devkit": "22.6.5",
-    "@trackunit/iris-app": "1.19.3",
+    "@trackunit/iris-app": "1.19.4",
     "cross-keychain": "^1.1.0",
     "jwt-decode": "^3.1.2"
   },

package/src/executors/utils/devServerTiming.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapResponseTiming = exports.shortenPath = exports.timeAsync = exports.time = exports.logEvent = exports.logTiming = void 0;
+// ---------------------------------------------------------------------------
+// Dev-server timing instrumentation
+//
+// Lightweight, zero-dependency timing logs for the Iris-app dev server.
+// Disabled by default; opt in with IRIS_TIMING=true. Logs to stdout with the
+// "[iris-timing]" prefix so they're easy to grep / filter.
+//
+// Each log line looks like:
+//   [iris-timing]  T+<elapsed_since_module_load>  <duration>  <label>
+//
+// Durations >1000ms are highlighted red, >200ms yellow, so the slow stuff
+// jumps out in a typical terminal. Per-request lines below the
+// TRANSFORM_LOG_THRESHOLD_MS are dropped to keep the output usable.
+// ---------------------------------------------------------------------------
+// Read lazily so tests / users can flip IRIS_TIMING at runtime.
+// Disabled by default; set IRIS_TIMING=true to enable.
+const isTimingEnabled = () => process.env.IRIS_TIMING === "true";
+const TRANSFORM_LOG_THRESHOLD_MS = 50;
+const TIMING_MODULE_START = performance.now();
+const padMs = (ms) => `${ms.toFixed(0).padStart(6, " ")}ms`;
+const colorize = (ms, text) => {
+    if (ms > 1000)
+        return `\x1b[31m${text}\x1b[0m`; // red
+    if (ms > 200)
+        return `\x1b[33m${text}\x1b[0m`; // yellow
+    return text;
+};
+/**
+ * Logs a single timing line: elapsed-since-module-load, duration, and label.
+ * Slow durations are colorized so they stand out in the terminal.
+ */
+const logTiming = (durationMs, label) => {
+    if (!isTimingEnabled())
+        return;
+    const elapsed = padMs(performance.now() - TIMING_MODULE_START);
+    const dur = colorize(durationMs, padMs(durationMs));
+    // eslint-disable-next-line no-console
+    console.log(`\x1b[36m[iris-timing]\x1b[0m T+${elapsed}  ${dur}  ${label}`);
+};
+exports.logTiming = logTiming;
+/**
+ * Logs a non-timed event (no duration column), e.g. "server: listening".
+ * Useful for marking moments in the dev-server lifecycle.
+ */
+const logEvent = (label) => {
+    if (!isTimingEnabled())
+        return;
+    const elapsed = padMs(performance.now() - TIMING_MODULE_START);
+    // eslint-disable-next-line no-console
+    console.log(`\x1b[36m[iris-timing]\x1b[0m T+${elapsed}              ${label}`);
+};
+exports.logEvent = logEvent;
+/** Wraps a synchronous function and logs its duration. */
+const time = (label, fn) => {
+    if (!isTimingEnabled())
+        return fn();
+    const start = performance.now();
+    try {
+        return fn();
+    }
+    finally {
+        (0, exports.logTiming)(performance.now() - start, label);
+    }
+};
+exports.time = time;
+/** Wraps an async function and logs its duration. */
+const timeAsync = async (label, fn) => {
+    if (!isTimingEnabled())
+        return fn();
+    const start = performance.now();
+    try {
+        return await fn();
+    }
+    finally {
+        (0, exports.logTiming)(performance.now() - start, label);
+    }
+};
+exports.timeAsync = timeAsync;
+/**
+ * Shortens long absolute paths to a workspace-relative form for log lines.
+ *   "/@fs/Users/mta/.../manager1/libs/css/core/src/lib/core.css"
+ *   -> "libs/css/core/src/lib/core.css"
+ */
+const shortenPath = (urlOrPath) => {
+    const idx = urlOrPath.indexOf("/manager1/");
+    if (idx >= 0)
+        return urlOrPath.substring(idx + "/manager1/".length);
+    const fsPrefix = "/@fs/";
+    if (urlOrPath.startsWith(fsPrefix))
+        return urlOrPath.substring(fsPrefix.length);
+    return urlOrPath;
+};
+exports.shortenPath = shortenPath;
+/**
+ * Logs the total server-side response time per request via the `finish` event,
+ * which fires once the response has been fully written. This corresponds to
+ * the `wait` time you see in browser network panels.
+ *
+ * Combined with the per-handler timings inside our own middleware, it lets us
+ * see whether slowness is in our code or in downstream Vite work (transforms,
+ * optimizeDeps, etc).
+ */
+const wrapResponseTiming = (req, res) => {
+    if (!isTimingEnabled())
+        return;
+    const start = performance.now();
+    res.on("finish", () => {
+        const durationMs = performance.now() - start;
+        if (durationMs >= TRANSFORM_LOG_THRESHOLD_MS) {
+            const url = req.url ?? "(no url)";
+            (0, exports.logTiming)(durationMs, `${req.method ?? "GET"} ${(0, exports.shortenPath)(url)}`);
+        }
+    });
+};
+exports.wrapResponseTiming = wrapResponseTiming;
+//# sourceMappingURL=devServerTiming.js.map

package/src/executors/utils/extensionLoaderCache.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExtensionLoaderCache = void 0;
+const devServerTiming_1 = require("./devServerTiming");
+const DEFAULT_TTL_MS = 5 * 60 * 1000;
+/**
+ * Creates an in-memory cache for the /extensionloader.js script.
+ *
+ * The /extensionloader.js handler proxies to https://iris.trackunit.app
+ * (or http://localhost:3000 when LOCAL=true). Without caching, every page
+ * load triggers a fresh network fetch -- and during a single cold load Vite
+ * typically reloads the page 2-3 times (because of optimizeDeps cascades),
+ * so the upstream is hit 3+ times. HAR profiling showed individual fetches
+ * costing 200ms-5s+ depending on CDN health, and one trace recorded a single
+ * ~5.2s fetch as the dominant gap in the dev waterfall.
+ *
+ * The script changes very rarely, so we cache it in memory with a TTL and
+ * dedupe concurrent fetches.
+ */
+const createExtensionLoaderCache = ({ getUrl, ttlMs = DEFAULT_TTL_MS, shouldBypassCache, }) => {
+    let cached = null;
+    let inflight = null;
+    const getCachedExtensionLoaderBody = async () => {
+        const url = getUrl();
+        const now = Date.now();
+        const bypass = shouldBypassCache?.() === true;
+        if (!bypass && cached !== null && cached.url === url && now - cached.fetchedAt < ttlMs) {
+            return cached.body;
+        }
+        if (inflight !== null) {
+            const settled = await inflight;
+            return settled.body;
+        }
+        const fetchPromise = (async () => {
+            (0, devServerTiming_1.logEvent)(`extensionloader cache: cold load (${url})`);
+            const body = await (0, devServerTiming_1.timeAsync)(`fetch ${url}`, async () => {
+                const resp = await fetch(url);
+                if (!resp.ok) {
+                    throw new Error(`upstream returned ${resp.status} ${resp.statusText}`);
+                }
+                return resp.text();
+            });
+            cached = { url, body, fetchedAt: Date.now() };
+            return { url, body };
+        })();
+        inflight = fetchPromise;
+        // Clear the inflight pointer once the fetch settles. Use then(cleanup, cleanup)
+        // instead of finally() so a rejection isn't re-thrown from this side-channel;
+        // the caller still observes the rejection via the awaited `fetchPromise`.
+        const clearInflightIfStillCurrent = () => {
+            if (inflight === fetchPromise) {
+                inflight = null;
+            }
+        };
+        fetchPromise.then(clearInflightIfStillCurrent, clearInflightIfStillCurrent);
+        const fetched = await fetchPromise;
+        return fetched.body;
+    };
+    return { getCachedExtensionLoaderBody };
+};
+exports.createExtensionLoaderCache = createExtensionLoaderCache;
+//# sourceMappingURL=extensionLoaderCache.js.map

package/src/executors/utils/getTrackunitIrisAppVitePlugins.js

@@ -11,6 +11,9 @@ const path = tslib_1.__importStar(require("node:path"));
 const vite_2 = require("vite");
 const vite_plugin_checker_1 = tslib_1.__importDefault(require("vite-plugin-checker"));
 const vite_plugin_css_injected_by_js_1 = tslib_1.__importDefault(require("vite-plugin-css-injected-by-js"));
+const devServerTiming_1 = require("./devServerTiming");
+const extensionLoaderCache_1 = require("./extensionLoaderCache");
+const manifestCache_1 = require("./manifestCache");
 // Only import enableTsConfigPath statically - other utilities are dynamically imported
 // AFTER tsconfig paths are registered to avoid oxc analysis warnings
 // MIME types for serving extension assets during development
@@ -57,7 +60,7 @@ const registerTsConfigPaths = (workspaceRoot, appDir) => {
  * Loads the Iris app manifest from the app directory.
  * Uses require() with cache clearing since Node.js doesn't support query strings in import paths.
  */
-const loadManifest = (workspaceRoot, appDir) => {
+const loadManifest = (workspaceRoot, appDir) => (0, devServerTiming_1.time)("loadManifest (re-import iris-app-manifest.ts)", () => {
     // Register tsconfig paths before loading the manifest
     registerTsConfigPaths(workspaceRoot, appDir);
     const manifestPath = path.join(appDir, "iris-app-manifest.ts");
@@ -72,7 +75,7 @@ const loadManifest = (workspaceRoot, appDir) => {
     const manifestModule = require(manifestPath);
     manifestModule.default.moduleFormat = "esm";
     return manifestModule.default;
-};
+});
 /**
  * Converts the shared dependencies from webpack format to Vite module federation format.
  * Handles both array and object variants of the Shared type.
@@ -138,7 +141,7 @@ const generateIndexHtml = ({ manifest, packageJson, options, }) => {
   </script>`
         : "";
     const devtools = options.config.mode === "development"
-        ? `<script nonce="{{nonce}}" src="http://localhost:8097"></script>
+        ? `<script nonce="{{nonce}}" defer src="http://localhost:8097"></script>
       ${iframeRedirect}
       <script nonce="{{nonce}}">
     if (typeof global === 'undefined') { window.global = window; }
@@ -159,18 +162,20 @@ const generateIndexHtml = ({ manifest, packageJson, options, }) => {
  * Returns an array of plugins including Module Federation configuration.
  */
 async function getTrackunitIrisAppVitePlugins(options) {
+    const pluginConstructionStart = performance.now();
+    (0, devServerTiming_1.logEvent)("plugin construction: started");
     const resolvedAppDir = path.resolve(options.appDir);
     const workspaceRoot = options.workspaceRoot ?? path.resolve(options.appDir, "../..");
     // Load manifest upfront for federation config
     const initialManifest = loadManifest(workspaceRoot, resolvedAppDir);
     // Get build utilities (tsconfig paths now registered via loadManifest)
     // Get an available port in the Iris app port range
-    const port = await (0, iris_app_build_utilities_1.getAvailablePort)(22220, 22229);
+    const port = await (0, devServerTiming_1.timeAsync)("getAvailablePort", () => (0, iris_app_build_utilities_1.getAvailablePort)(22220, 22229));
     // Get module federation configuration from manifest
-    const webpackExposes = await (0, iris_app_build_utilities_1.getExposedExtensions)({
+    const webpackExposes = await (0, devServerTiming_1.timeAsync)(`getExposedExtensions (${initialManifest.extensions.length} extensions)`, () => (0, iris_app_build_utilities_1.getExposedExtensions)({
         nxRootDir: workspaceRoot,
         manifest: initialManifest,
-    });
+    }));
     const shared = (0, iris_app_build_utilities_1.getSharedDependencies)({ manifest: initialManifest });
     const viteExposes = convertExposesToViteFormat(webpackExposes);
     const viteShared = convertSharedToViteFormat(shared);
@@ -246,7 +251,6 @@ async function getTrackunitIrisAppVitePlugins(options) {
     };
     // Create the iris app plugin
     let config;
-    let manifest = initialManifest;
     const reloadManifest = () => {
         return loadManifest(workspaceRoot, resolvedAppDir);
     };
@@ -259,6 +263,23 @@ async function getTrackunitIrisAppVitePlugins(options) {
         manifestCopy.extensions = (0, iris_app_build_utilities_1.updateExtensions)([...manifestData.extensions]);
         return (0, iris_app_build_utilities_1.injectFullDescriptionImages)(manifestCopy, resolvedAppDir);
     };
+    const manifestCache = (0, manifestCache_1.createManifestCache)({
+        reloadManifest,
+        generateManifestJson,
+        initialManifest,
+    });
+    // The /extensionloader.js handler proxies to https://iris.trackunit.app
+    // (or http://localhost:3000 when LOCAL=true). The script changes very
+    // rarely, so we cache the body in memory with a TTL and dedupe concurrent
+    // fetches via createExtensionLoaderCache. Set IRIS_EXTENSIONLOADER_NO_CACHE=1
+    // to bypass the cache for debugging.
+    const getExtensionLoaderUrl = () => process.env.LOCAL === "true"
+        ? "http://localhost:3000/extensionloader.js"
+        : "https://iris.trackunit.app/extensionloader.js";
+    const extensionLoaderCache = (0, extensionLoaderCache_1.createExtensionLoaderCache)({
+        getUrl: getExtensionLoaderUrl,
+        shouldBypassCache: () => process.env.IRIS_EXTENSIONLOADER_NO_CACHE === "1",
+    });
     // No explicit type annotation to avoid excessive stack depth error with federation plugin's complex types
     const irisAppPlugin = {
         name: "trackunit-iris-app-vite-configuration",
@@ -285,7 +306,7 @@ async function getTrackunitIrisAppVitePlugins(options) {
                     },
                 },
                 // PostCSS configuration for Tailwind CSS v4
-                // Using @tailwindcss/postcss instead of @tailwindcss/vite for better monorepo support
+                // Using @tailwindcss/postcss instead of @tailwindcss/vite for better monorepo support.
                 css: {
                     postcss: {
                         plugins: [require("@tailwindcss/postcss")({})],
@@ -358,15 +379,37 @@ async function getTrackunitIrisAppVitePlugins(options) {
             config = resolvedConfig;
         },
         buildStart() {
-            manifest = reloadManifest();
+            manifestCache.reloadManifestSync();
         },
         configureServer(server) {
+            // Watch iris-app-manifest.ts and invalidate the manifest cache on change so
+            // HMR picks up edits (e.g. adding/removing extensions). All other paths
+            // serve from the cache populated by the first request.
+            const manifestFilePath = path.join(resolvedAppDir, "iris-app-manifest.ts");
+            server.watcher.add(manifestFilePath);
+            server.watcher.on("change", changedPath => {
+                if (path.normalize(changedPath) === path.normalize(manifestFilePath)) {
+                    manifestCache.invalidateManifestCache();
+                    (0, devServerTiming_1.logEvent)("manifest cache: invalidated (iris-app-manifest.ts changed)");
+                }
+            });
+            // Request timing middleware - MUST be registered before any other middleware
+            // so we observe the full server-side response time. Logs to stdout when
+            // the response takes longer than TRANSFORM_LOG_THRESHOLD_MS. Enable with
+            // IRIS_TIMING=true.
+            server.middlewares.use((req, res, next) => {
+                (0, devServerTiming_1.wrapResponseTiming)(req, res);
+                next();
+            });
             // Route /invoke requests to local serverside extensions when available.
             server.middlewares.use("/invoke", (0, iris_app_build_utilities_1.createInvokeProxyMiddleware)(options.serversidePortMap));
             // Serve extension assets from source during development (/{extensionId}/... → {sourceRoot}/...)
             server.middlewares.use((req, res, next) => {
                 const url = req.url?.split("?")[0] ?? "/";
-                const filePath = resolveExtensionAsset(url, manifest ?? reloadManifest(), workspaceRoot);
+                // Use the in-memory manifest if available; fall back to initialManifest
+                // (loaded once at plugin construction) so this synchronous middleware
+                // never blocks on a slow manifest reload.
+                const filePath = resolveExtensionAsset(url, manifestCache.getManifestSync() ?? initialManifest, workspaceRoot);
                 if (filePath) {
                     res.setHeader("Content-Type", getMimeType(filePath));
                     res.end(fs.readFileSync(filePath));
@@ -415,8 +458,7 @@ async function getTrackunitIrisAppVitePlugins(options) {
                 if (req.url === "/manifest.json") {
                     void (async () => {
                         try {
-                            manifest = reloadManifest();
-                            const manifestJson = generateManifestJson(manifest);
+                            const manifestJson = await manifestCache.getCachedManifestJson();
                             res.setHeader("Content-Type", "application/json");
                             res.end(JSON.stringify(manifestJson, null, 2));
                         }
@@ -444,14 +486,15 @@ async function getTrackunitIrisAppVitePlugins(options) {
                     }
                 }
                 // Serve manifestAndToken during development (async route - handle response ourselves)
+                // Calls getCachedManifestJson directly instead of HTTP-fetching /manifest.json
+                // to avoid a redundant manifest reload on every request (the host calls this
+                // endpoint multiple times during initial app boot).
                 if (req.url?.startsWith("/manifestAndToken")) {
                     void (async () => {
                         try {
-                            const host = req.headers.host || "localhost";
-                            const resp = await fetch(`http://${host}/manifest.json`);
-                            const body = await resp.json();
+                            const manifestJson = await manifestCache.getCachedManifestJson();
                             res.setHeader("Content-Type", "application/json");
-                            res.end(JSON.stringify({ manifest: body }));
+                            res.end(JSON.stringify({ manifest: manifestJson }));
                         }
                         catch (e) {
                             // eslint-disable-next-line no-console
@@ -462,17 +505,13 @@ async function getTrackunitIrisAppVitePlugins(options) {
                     })();
                     return; // Don't call next() - we're handling this route
                 }
-                // Serve extensionloader.js during development (async route - handle response ourselves)
+                // Serve extensionloader.js during development.
+                // To test extensionloader locally set LOCAL=true in front of the serve command.
+                // The fetched body is cached in memory; see createExtensionLoaderCache.
                 if (req.url?.startsWith("/extensionloader.js")) {
                     void (async () => {
                         try {
-                            // To test extensionloader locally set LOCAL=true in front of the serve command
-                            let loaderUrl = "https://iris.trackunit.app/extensionloader.js";
-                            if (process.env.LOCAL === "true") {
-                                loaderUrl = "http://localhost:3000/extensionloader.js";
-                            }
-                            const resp = await fetch(loaderUrl);
-                            const body = await resp.text();
+                            const body = await extensionLoaderCache.getCachedExtensionLoaderBody();
                             res.setHeader("Content-Type", "application/javascript");
                             res.end(body);
                         }
@@ -494,11 +533,11 @@ async function getTrackunitIrisAppVitePlugins(options) {
                     if (isRootOrSpaRoute) {
                         void (async () => {
                             try {
-                                manifest = reloadManifest();
+                                const currentManifest = await manifestCache.getCachedManifest();
                                 const packageJsonPath = path.join(resolvedAppDir, "package.json");
                                 const packageJson = fs.readFileSync(packageJsonPath, "utf8");
-                                const html = generateIndexHtml({ manifest, packageJson, options });
-                                const transformedHtml = await server.transformIndexHtml(req.url ?? "/", html);
+                                const html = generateIndexHtml({ manifest: currentManifest, packageJson, options });
+                                const transformedHtml = await (0, devServerTiming_1.timeAsync)(`server.transformIndexHtml(${(0, devServerTiming_1.shortenPath)(url)})`, () => server.transformIndexHtml(req.url ?? "/", html));
                                 res.setHeader("Content-Type", "text/html");
                                 res.end(transformedHtml);
                             }
@@ -516,15 +555,14 @@ async function getTrackunitIrisAppVitePlugins(options) {
             });
             // Log success message when server starts
             server.httpServer?.once("listening", () => {
+                (0, devServerTiming_1.logEvent)("server: listening");
                 setTimeout(() => {
                     (0, iris_app_build_utilities_1.logInfo)(`\n✨ Iris App is now started, check it out ✨\nhttps://new.manager.trackunit.com/goto/iris-app-dev\n`);
                 }, 100);
             });
         },
         generateBundle() {
-            if (!manifest) {
-                manifest = reloadManifest();
-            }
+            const manifest = manifestCache.getManifestSync() ?? manifestCache.reloadManifestSync();
             const packageJsonPath = path.join(resolvedAppDir, "package.json");
             const packageJson = fs.readFileSync(packageJsonPath, "utf8");
             // Generate and emit manifest.json
@@ -549,7 +587,7 @@ async function getTrackunitIrisAppVitePlugins(options) {
         },
         closeBundle() {
             if (config.command === "build") {
-                const manifestForCopy = manifest ?? reloadManifest();
+                const manifestForCopy = manifestCache.getManifestSync() ?? manifestCache.reloadManifestSync();
                 const copyPatterns = (0, iris_app_build_utilities_1.getCopyPatterns)({
                     nxRootDir: workspaceRoot,
                     appDir: resolvedAppDir,
@@ -604,7 +642,7 @@ async function getTrackunitIrisAppVitePlugins(options) {
     //
     // NOTE: Tailwind CSS is configured via PostCSS (in baseConfig.css.postcss above)
     // NOT using @tailwindcss/vite because it doesn't respect tailwind.config.js content paths
-    // PostCSS approach matches Rspack and properly uses getTailwindContentForApp() from config files
+    // PostCSS approach matches Rspack and properly uses Tailwind v4 config files.
     const plugins = [
         (0, nx_tsconfig_paths_plugin_1.nxViteTsPaths)(),
         // React Fast Refresh — enables HMR for React components so file changes
@@ -626,6 +664,7 @@ async function getTrackunitIrisAppVitePlugins(options) {
         }),
         bundleAnalyzerPlugin,
     ];
+    (0, devServerTiming_1.logTiming)(performance.now() - pluginConstructionStart, "plugin construction: complete");
     return plugins.filter(Boolean);
 }
 //# sourceMappingURL=getTrackunitIrisAppVitePlugins.js.map

package/src/executors/utils/manifestCache.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createManifestCache = void 0;
+const devServerTiming_1 = require("./devServerTiming");
+/**
+ * Creates an in-memory cache for the Iris-app manifest.
+ *
+ * The cache deduplicates concurrent /manifest.json and /manifestAndToken
+ * requests so they don't re-resolve the manifest + all 25 extension entries
+ * on every call. Cold-load profiling showed each request taking ~3s; with the
+ * host firing several parallel calls during boot, that stacked into >6s of
+ * latency before any extension code could load.
+ *
+ * The cache is invalidated when iris-app-manifest.ts changes; callers wire
+ * that up through the dev server's file watcher.
+ */
+const createManifestCache = ({ reloadManifest, generateManifestJson, initialManifest, }) => {
+    let manifest = initialManifest;
+    let manifestJsonCache = null;
+    // Shared promise for an in-flight reload, used to dedupe concurrent requests
+    // that arrive while the cache is empty.
+    let inflightManifestReload = null;
+    const ensureManifestLoaded = () => {
+        if (manifest !== undefined && manifestJsonCache !== null) {
+            return Promise.resolve(manifestJsonCache);
+        }
+        if (inflightManifestReload !== null) {
+            (0, devServerTiming_1.logEvent)("manifest cache: joining in-flight reload (deduped)");
+            return inflightManifestReload;
+        }
+        (0, devServerTiming_1.logEvent)("manifest cache: cold load (cache empty)");
+        const reloadPromise = (async () => {
+            const loadedManifest = manifest ?? reloadManifest();
+            manifest = loadedManifest;
+            manifestJsonCache = (0, devServerTiming_1.time)("generateManifestJson", () => generateManifestJson(loadedManifest));
+            return manifestJsonCache;
+        })();
+        inflightManifestReload = reloadPromise;
+        // Clear the inflight pointer once the reload settles so post-invalidate
+        // reads start a fresh load instead of joining this resolved/rejected
+        // promise. The identity check guards against `invalidateManifestCache`
+        // having already nulled it out (or replaced it with a newer reload). We
+        // attach the cleanup with then(cleanup, cleanup) instead of finally() so
+        // a rejection isn't re-thrown from this side-channel; the caller still
+        // observes the rejection via the returned `reloadPromise`.
+        const clearInflightIfStillCurrent = () => {
+            if (inflightManifestReload === reloadPromise) {
+                inflightManifestReload = null;
+            }
+        };
+        reloadPromise.then(clearInflightIfStillCurrent, clearInflightIfStillCurrent);
+        return reloadPromise;
+    };
+    const getCachedManifestJson = () => ensureManifestLoaded();
+    const getCachedManifest = async () => {
+        await ensureManifestLoaded();
+        if (manifest === undefined) {
+            throw new Error("Manifest unexpectedly undefined after reload");
+        }
+        return manifest;
+    };
+    const getManifestSync = () => manifest;
+    const reloadManifestSync = () => {
+        const fresh = reloadManifest();
+        manifest = fresh;
+        return fresh;
+    };
+    const invalidateManifestCache = () => {
+        manifestJsonCache = null;
+        manifest = undefined;
+    };
+    return {
+        getCachedManifestJson,
+        getCachedManifest,
+        getManifestSync,
+        reloadManifestSync,
+        invalidateManifestCache,
+    };
+};
+exports.createManifestCache = createManifestCache;
+//# sourceMappingURL=manifestCache.js.map