@docusaurus/core 3.7.0 → 3.8.0

package/lib/commands/utils/openBrowser/openBrowser.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = openBrowser;
+const tslib_1 = require("tslib");
+// This code was initially in CRA/react-dev-utils (deprecated in 2025)
+// We copied and refactored it
+// See https://github.com/facebook/docusaurus/pull/10956
+// See https://github.com/facebook/create-react-app/blob/main/packages/react-dev-utils/openBrowser.js
+/* eslint-disable */
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const open_1 = tslib_1.__importDefault(require("open"));
+const logger_1 = require("@docusaurus/logger");
+const execPromise = (0, util_1.promisify)(child_process_1.exec);
+// Not sure if we need this, but let's keep a secret escape hatch
+// CRA/react-dev-utils supported BROWSER/BROWSER_ARGS
+const BrowserEnv = process.env.DOCUSAURUS_BROWSER;
+const BrowserEnvArgs = process.env.DOCUSAURUS_BROWSER_ARGS
+    ? process.env.DOCUSAURUS_BROWSER_ARGS.split(' ')
+    : [];
+// If we're on OS X, the user hasn't specifically
+// requested a different browser, we can try opening
+// Chrome with AppleScript. This lets us reuse an
+// existing tab when possible instead of creating a new one.
+// Copied from https://github.com/facebook/create-react-app/blob/main/packages/react-dev-utils/openBrowser.js
+async function tryOpenWithAppleScript({ url, browser, }) {
+    const shouldTryOpenChromiumWithAppleScript = process.platform === 'darwin' &&
+        (typeof browser !== 'string' || browser === 'google chrome');
+    if (!shouldTryOpenChromiumWithAppleScript) {
+        return false;
+    }
+    if (shouldTryOpenChromiumWithAppleScript) {
+        async function getBrowsersToTry() {
+            // Will use the first open browser found from list
+            const supportedChromiumBrowsers = [
+                'Google Chrome Canary',
+                'Google Chrome Dev',
+                'Google Chrome Beta',
+                'Google Chrome',
+                'Microsoft Edge',
+                'Brave Browser',
+                'Vivaldi',
+                'Chromium',
+            ];
+            // Among all the supported browsers, retrieves to stdout the active ones
+            const command = `ps cax -o command | grep -E "^(${supportedChromiumBrowsers.join('|')})$"`;
+            const result = await execPromise(command);
+            const activeBrowsers = result.stdout.toString().trim().split('\n');
+            // This preserves the initial browser order
+            // We open Google Chrome Canary in priority over Google Chrome
+            return supportedChromiumBrowsers.filter((b) => activeBrowsers.includes(b));
+        }
+        async function tryBrowser(browserName) {
+            try {
+                // This command runs the openChrome.applescript (copied from CRA)
+                const command = `osascript openChrome.applescript "${encodeURI(url)}" "${browserName}"`;
+                await execPromise(command, {
+                    cwd: __dirname,
+                });
+                return true;
+            }
+            catch (err) {
+                console.error(`Failed to open browser ${browserName} with AppleScript`, err);
+                return false;
+            }
+        }
+        const browsers = await logger_1.PerfLogger.async('getBrowsersToTry', () => getBrowsersToTry());
+        for (let browser of browsers) {
+            const success = await logger_1.PerfLogger.async(browser, () => tryBrowser(browser));
+            if (success) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function toOpenApp(params) {
+    if (!params.browser) {
+        return undefined;
+    }
+    // Handles "cross-platform" shortcuts like "chrome", "firefox", "edge"
+    if (open_1.default.apps[params.browser]) {
+        return {
+            name: open_1.default.apps[params.browser],
+            arguments: params.browserArgs,
+        };
+    }
+    // Fallback to platform-specific app name
+    return {
+        name: params.browser,
+        arguments: params.browserArgs,
+    };
+}
+async function startBrowserProcess(params) {
+    if (await logger_1.PerfLogger.async('tryOpenWithAppleScript', () => tryOpenWithAppleScript(params))) {
+        return true;
+    }
+    try {
+        await (0, open_1.default)(params.url, {
+            app: toOpenApp(params),
+            wait: false,
+        });
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+/**
+ * Returns true if it opened a browser
+ */
+async function openBrowser(url) {
+    return startBrowserProcess({
+        url,
+        browser: BrowserEnv,
+        browserArgs: BrowserEnvArgs,
+    });
+}

package/lib/commands/utils/openBrowser/openChrome.applescript

@@ -0,0 +1,94 @@
+(*
+Copyright (c) 2015-present, Facebook, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*)
+
+property targetTab: null
+property targetTabIndex: -1
+property targetWindow: null
+property theProgram: "Google Chrome"
+
+on run argv
+  set theURL to item 1 of argv
+
+  -- Allow requested program to be optional,
+  -- default to Google Chrome
+  if (count of argv) > 1 then
+    set theProgram to item 2 of argv
+  end if
+
+  using terms from application "Google Chrome"
+    tell application theProgram
+
+      if (count every window) = 0 then
+        make new window
+      end if
+
+      -- 1: Looking for tab running debugger
+      -- then, Reload debugging tab if found
+      -- then return
+      set found to my lookupTabWithUrl(theURL)
+      if found then
+        set targetWindow's active tab index to targetTabIndex
+        tell targetTab to reload
+        tell targetWindow to activate
+        set index of targetWindow to 1
+        return
+      end if
+
+      -- 2: Looking for Empty tab
+      -- In case debugging tab was not found
+      -- We try to find an empty tab instead
+      set found to my lookupTabWithUrl("chrome://newtab/")
+      if found then
+        set targetWindow's active tab index to targetTabIndex
+        set URL of targetTab to theURL
+        tell targetWindow to activate
+        return
+      end if
+
+      -- 3: Create new tab
+      -- both debugging and empty tab were not found
+      -- make a new tab with url
+      tell window 1
+        activate
+        make new tab with properties {URL:theURL}
+      end tell
+    end tell
+  end using terms from
+end run
+
+-- Function:
+-- Lookup tab with given url
+-- if found, store tab, index, and window in properties
+-- (properties were declared on top of file)
+on lookupTabWithUrl(lookupUrl)
+  using terms from application "Google Chrome"
+    tell application theProgram
+      -- Find a tab with the given url
+      set found to false
+      set theTabIndex to -1
+      repeat with theWindow in every window
+        set theTabIndex to 0
+        repeat with theTab in every tab of theWindow
+          set theTabIndex to theTabIndex + 1
+          if (theTab's URL as string) contains lookupUrl then
+            -- assign tab, tab index, and window to properties
+            set targetTab to theTab
+            set targetTabIndex to theTabIndex
+            set targetWindow to theWindow
+            set found to true
+            exit repeat
+          end if
+        end repeat
+
+        if found then
+          exit repeat
+        end if
+      end repeat
+    end tell
+  end using terms from
+  return found
+end lookupTabWithUrl

package/lib/server/configValidation.d.ts

@@ -5,12 +5,14 @@
  * LICENSE file in the root directory of this source tree.
  */
 import { Joi } from '@docusaurus/utils-validation';
-import type { FasterConfig, FutureConfig, StorageConfig } from '@docusaurus/types/src/config';
+import type { FasterConfig, FutureConfig, FutureV4Config, StorageConfig } from '@docusaurus/types/src/config';
 import type { DocusaurusConfig, I18nConfig, MarkdownConfig } from '@docusaurus/types';
 export declare const DEFAULT_I18N_CONFIG: I18nConfig;
 export declare const DEFAULT_STORAGE_CONFIG: StorageConfig;
 export declare const DEFAULT_FASTER_CONFIG: FasterConfig;
 export declare const DEFAULT_FASTER_CONFIG_TRUE: FasterConfig;
+export declare const DEFAULT_FUTURE_V4_CONFIG: FutureV4Config;
+export declare const DEFAULT_FUTURE_V4_CONFIG_TRUE: FutureV4Config;
 export declare const DEFAULT_FUTURE_CONFIG: FutureConfig;
 export declare const DEFAULT_MARKDOWN_CONFIG: MarkdownConfig;
 export declare const DEFAULT_CONFIG: Pick<DocusaurusConfig, 'i18n' | 'future' | 'onBrokenLinks' | 'onBrokenAnchors' | 'onBrokenMarkdownLinks' | 'onDuplicateRoutes' | 'plugins' | 'themes' | 'presets' | 'headTags' | 'stylesheets' | 'scripts' | 'clientModules' | 'customFields' | 'themeConfig' | 'titleDelimiter' | 'noIndex' | 'tagline' | 'baseUrlIssueBanner' | 'staticDirectories' | 'markdown'>;

package/lib/server/configValidation.js

@@ -6,11 +6,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigSchema = exports.DEFAULT_CONFIG = exports.DEFAULT_MARKDOWN_CONFIG = exports.DEFAULT_FUTURE_CONFIG = exports.DEFAULT_FASTER_CONFIG_TRUE = exports.DEFAULT_FASTER_CONFIG = exports.DEFAULT_STORAGE_CONFIG = exports.DEFAULT_I18N_CONFIG = void 0;
+exports.ConfigSchema = exports.DEFAULT_CONFIG = exports.DEFAULT_MARKDOWN_CONFIG = exports.DEFAULT_FUTURE_CONFIG = exports.DEFAULT_FUTURE_V4_CONFIG_TRUE = exports.DEFAULT_FUTURE_V4_CONFIG = exports.DEFAULT_FASTER_CONFIG_TRUE = exports.DEFAULT_FASTER_CONFIG = exports.DEFAULT_STORAGE_CONFIG = exports.DEFAULT_I18N_CONFIG = void 0;
 exports.validateConfig = validateConfig;
+const tslib_1 = require("tslib");
 const utils_1 = require("@docusaurus/utils");
 const utils_validation_1 = require("@docusaurus/utils-validation");
 const utils_common_1 = require("@docusaurus/utils-common");
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
 const DEFAULT_I18N_LOCALE = 'en';
 exports.DEFAULT_I18N_CONFIG = {
     defaultLocale: DEFAULT_I18N_LOCALE,
@@ -29,6 +31,8 @@ exports.DEFAULT_FASTER_CONFIG = {
     lightningCssMinimizer: false,
     mdxCrossCompilerCache: false,
     rspackBundler: false,
+    rspackPersistentCache: false,
+    ssgWorkerThreads: false,
 };
 // When using the "faster: true" shortcut
 exports.DEFAULT_FASTER_CONFIG_TRUE = {
@@ -38,8 +42,20 @@ exports.DEFAULT_FASTER_CONFIG_TRUE = {
     lightningCssMinimizer: true,
     mdxCrossCompilerCache: true,
     rspackBundler: true,
+    rspackPersistentCache: true,
+    ssgWorkerThreads: true,
+};
+exports.DEFAULT_FUTURE_V4_CONFIG = {
+    removeLegacyPostBuildHeadAttribute: false,
+    useCssCascadeLayers: false,
+};
+// When using the "v4: true" shortcut
+exports.DEFAULT_FUTURE_V4_CONFIG_TRUE = {
+    removeLegacyPostBuildHeadAttribute: true,
+    useCssCascadeLayers: true,
 };
 exports.DEFAULT_FUTURE_CONFIG = {
+    v4: exports.DEFAULT_FUTURE_V4_CONFIG,
     experimental_faster: exports.DEFAULT_FASTER_CONFIG,
     experimental_storage: exports.DEFAULT_STORAGE_CONFIG,
     experimental_router: 'browser',
@@ -155,11 +171,22 @@ const FASTER_CONFIG_SCHEMA = utils_validation_1.Joi.alternatives()
     lightningCssMinimizer: utils_validation_1.Joi.boolean().default(exports.DEFAULT_FASTER_CONFIG.lightningCssMinimizer),
     mdxCrossCompilerCache: utils_validation_1.Joi.boolean().default(exports.DEFAULT_FASTER_CONFIG.mdxCrossCompilerCache),
     rspackBundler: utils_validation_1.Joi.boolean().default(exports.DEFAULT_FASTER_CONFIG.rspackBundler),
+    rspackPersistentCache: utils_validation_1.Joi.boolean().default(exports.DEFAULT_FASTER_CONFIG.rspackPersistentCache),
+    ssgWorkerThreads: utils_validation_1.Joi.boolean().default(exports.DEFAULT_FASTER_CONFIG.ssgWorkerThreads),
 }), utils_validation_1.Joi.boolean()
     .required()
     .custom((bool) => bool ? exports.DEFAULT_FASTER_CONFIG_TRUE : exports.DEFAULT_FASTER_CONFIG))
     .optional()
     .default(exports.DEFAULT_FASTER_CONFIG);
+const FUTURE_V4_SCHEMA = utils_validation_1.Joi.alternatives()
+    .try(utils_validation_1.Joi.object({
+    removeLegacyPostBuildHeadAttribute: utils_validation_1.Joi.boolean().default(exports.DEFAULT_FUTURE_V4_CONFIG.removeLegacyPostBuildHeadAttribute),
+    useCssCascadeLayers: utils_validation_1.Joi.boolean().default(exports.DEFAULT_FUTURE_V4_CONFIG.useCssCascadeLayers),
+}), utils_validation_1.Joi.boolean()
+    .required()
+    .custom((bool) => bool ? exports.DEFAULT_FUTURE_V4_CONFIG_TRUE : exports.DEFAULT_FUTURE_V4_CONFIG))
+    .optional()
+    .default(exports.DEFAULT_FUTURE_V4_CONFIG);
 const STORAGE_CONFIG_SCHEMA = utils_validation_1.Joi.object({
     type: utils_validation_1.Joi.string()
         .equal('localStorage', 'sessionStorage')
@@ -171,6 +198,7 @@ const STORAGE_CONFIG_SCHEMA = utils_validation_1.Joi.object({
     .optional()
     .default(exports.DEFAULT_STORAGE_CONFIG);
 const FUTURE_CONFIG_SCHEMA = utils_validation_1.Joi.object({
+    v4: FUTURE_V4_SCHEMA,
     experimental_faster: FASTER_CONFIG_SCHEMA,
     experimental_storage: STORAGE_CONFIG_SCHEMA,
     experimental_router: utils_validation_1.Joi.string()
@@ -308,6 +336,20 @@ exports.ConfigSchema = utils_validation_1.Joi.object({
 }).messages({
     'docusaurus.configValidationWarning': 'Docusaurus config validation warning. Field {#label}: {#warningMessage}',
 });
+// Expressing this kind of logic in Joi is a pain
+// We also want to decouple logic from Joi: easier to remove it later!
+function ensureDocusaurusConfigConsistency(config) {
+    if (config.future.experimental_faster.ssgWorkerThreads &&
+        !config.future.v4.removeLegacyPostBuildHeadAttribute) {
+        throw new Error(`Docusaurus config ${logger_1.default.code('future.experimental_faster.ssgWorkerThreads')} requires the future flag ${logger_1.default.code('future.v4.removeLegacyPostBuildHeadAttribute')} to be turned on.
+If you use Docusaurus Faster, we recommend that you also activate Docusaurus v4 future flags: ${logger_1.default.code('{future: {v4: true}}')}
+All the v4 future flags are documented here: https://docusaurus.io/docs/api/docusaurus-config#future`);
+    }
+    if (config.future.experimental_faster.rspackPersistentCache &&
+        !config.future.experimental_faster.rspackBundler) {
+        throw new Error(`Docusaurus config flag ${logger_1.default.code('future.experimental_faster.rspackPersistentCache')} requires the flag ${logger_1.default.code('future.experimental_faster.rspackBundler')} to be turned on.`);
+    }
+}
 // TODO move to @docusaurus/utils-validation
 function validateConfig(config, siteConfigPath) {
     const { error, warning, value } = exports.ConfigSchema.validate(config, {
@@ -329,7 +371,6 @@ function validateConfig(config, siteConfigPath) {
             : formattedError;
         throw new Error(formattedError);
     }
-    else {
-        return value;
-    }
+    ensureDocusaurusConfigConsistency(value);
+    return value;
 }

package/lib/ssg/ssgEnv.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare const SSGConcurrency: number;
+export declare const SSGWorkerThreadCount: number | undefined;
+export declare const SSGWorkerThreadTaskSize: number;
+export declare const SSGWorkerThreadRecyclerMaxMemory: number | undefined;

package/lib/ssg/ssgEnv.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSGWorkerThreadRecyclerMaxMemory = exports.SSGWorkerThreadTaskSize = exports.SSGWorkerThreadCount = exports.SSGConcurrency = void 0;
+// Secret way to set SSR plugin async concurrency option
+// Waiting for feedback before documenting this officially?
+// TODO Docusaurus v4, rename SSR => SSG
+exports.SSGConcurrency = process.env.DOCUSAURUS_SSR_CONCURRENCY
+    ? parseInt(process.env.DOCUSAURUS_SSR_CONCURRENCY, 10)
+    : // Not easy to define a reasonable option default
+        // Will still be better than Infinity
+        // See also https://github.com/sindresorhus/p-map/issues/24
+        32;
+// Secret way to set SSR plugin async concurrency option
+// Waiting for feedback before documenting this officially?
+exports.SSGWorkerThreadCount = process.env
+    .DOCUSAURUS_SSG_WORKER_THREAD_COUNT
+    ? parseInt(process.env.DOCUSAURUS_SSG_WORKER_THREAD_COUNT, 10)
+    : undefined;
+// Number of pathnames to SSG per worker task
+exports.SSGWorkerThreadTaskSize = process.env
+    .DOCUSAURUS_SSG_WORKER_THREAD_TASK_SIZE
+    ? parseInt(process.env.DOCUSAURUS_SSG_WORKER_THREAD_TASK_SIZE, 10)
+    : 10; // TODO need fine-tuning
+// Controls worker thread recycling behavior (maxMemoryLimitBeforeRecycle)
+// See https://github.com/facebook/docusaurus/pull/11166
+// See https://github.com/facebook/docusaurus/issues/11161
+exports.SSGWorkerThreadRecyclerMaxMemory = process.env
+    .DOCUSAURUS_SSG_WORKER_THREAD_RECYCLER_MAX_MEMORY
+    ? parseInt(process.env.DOCUSAURUS_SSG_WORKER_THREAD_RECYCLER_MAX_MEMORY, 10)
+    : // 1 GB is a quite reasonable max value
+        // It should work well even for large sites
+        1000000000;

package/lib/ssg/ssgExecutor.js

@@ -7,18 +7,128 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeSSG = executeSSG;
-const logger_1 = require("@docusaurus/logger");
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const node_url_1 = require("node:url");
+const os_1 = tslib_1.__importDefault(require("os"));
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const logger_1 = tslib_1.__importStar(require("@docusaurus/logger"));
 const ssgParams_1 = require("./ssgParams");
-const ssg_1 = require("./ssg");
 const ssgTemplate_1 = require("./ssgTemplate");
+const ssgEnv_1 = require("./ssgEnv");
 const ssgUtils_1 = require("./ssgUtils");
-// TODO Docusaurus v4 - introduce SSG worker threads
+const ssgGlobalResult_1 = require("./ssgGlobalResult");
+const ssgWorkerInline_1 = require("./ssgWorkerInline");
+const createSimpleSSGExecutor = async ({ params, pathnames, }) => {
+    return {
+        run: () => {
+            return logger_1.PerfLogger.async('SSG (current thread)', async () => {
+                const ssgResults = await (0, ssgWorkerInline_1.executeSSGInlineTask)({
+                    pathnames,
+                    params,
+                });
+                return (0, ssgGlobalResult_1.createGlobalSSGResult)(ssgResults);
+            });
+        },
+        destroy: async () => {
+            // nothing to do
+        },
+    };
+};
+// Sensible default that gives decent performances
+// It's hard to have a perfect formula that works for all hosts
+// Each thread has some creation overhead
+// Having 1 thread per cpu doesn't necessarily improve perf on small sites
+// We want to ensure that we don't create a worker thread for less than x paths
+function inferNumberOfThreads({ pageCount, cpuCount, minPagesPerCpu, }) {
+    // Calculate "ideal" amount of threads based on the number of pages to render
+    const threadsByWorkload = Math.ceil(pageCount / minPagesPerCpu);
+    // Use the smallest of threadsByWorkload or cpuCount, ensuring min=1 thread
+    return Math.max(1, Math.min(threadsByWorkload, cpuCount));
+}
+function getNumberOfThreads(pathnames) {
+    if (typeof ssgEnv_1.SSGWorkerThreadCount !== 'undefined') {
+        return ssgEnv_1.SSGWorkerThreadCount;
+    }
+    // See also https://github.com/tinylibs/tinypool/pull/108
+    const cpuCount = 
+    // TODO Docusaurus v4: bump node, availableParallelism() now always exists
+    typeof os_1.default.availableParallelism === 'function'
+        ? os_1.default.availableParallelism()
+        : os_1.default.cpus().length;
+    return inferNumberOfThreads({
+        pageCount: pathnames.length,
+        cpuCount,
+        // These are "magic value" that we should refine based on user feedback
+        // Local tests show that it's not worth spawning new workers for few pages
+        minPagesPerCpu: 100,
+    });
+}
+const createPooledSSGExecutor = async ({ params, pathnames, }) => {
+    const numberOfThreads = getNumberOfThreads(pathnames);
+    // When the inferred or provided number of threads is just 1
+    // It's not worth it to use a thread pool
+    // This also allows users to disable the thread pool with the env variable
+    // DOCUSAURUS_SSG_WORKER_THREADS=1
+    if (numberOfThreads === 1) {
+        return createSimpleSSGExecutor({ params, pathnames });
+    }
+    const pool = await logger_1.PerfLogger.async(`Create SSG thread pool - ${logger_1.default.cyan(numberOfThreads)} threads`, async () => {
+        const Tinypool = await import('tinypool').then((m) => m.default);
+        const workerURL = (0, node_url_1.pathToFileURL)(path.resolve(__dirname, 'ssgWorkerThread.js'));
+        return new Tinypool({
+            filename: workerURL.pathname,
+            minThreads: numberOfThreads,
+            maxThreads: numberOfThreads,
+            concurrentTasksPerWorker: 1,
+            runtime: 'worker_threads',
+            isolateWorkers: false,
+            workerData: { params },
+            // WORKER MEMORY MANAGEMENT
+            // Allows containing SSG memory leaks with a thread recycling workaround
+            // See https://github.com/facebook/docusaurus/pull/11166
+            // See https://github.com/facebook/docusaurus/issues/11161
+            maxMemoryLimitBeforeRecycle: ssgEnv_1.SSGWorkerThreadRecyclerMaxMemory,
+            resourceLimits: {
+            // For some reason I can't figure out how to limit memory on a worker
+            // See https://x.com/sebastienlorber/status/1920781195618513143
+            },
+        });
+    });
+    const pathnamesChunks = lodash_1.default.chunk(pathnames, ssgEnv_1.SSGWorkerThreadTaskSize);
+    // Tiny wrapper for type-safety
+    const submitTask = async (task) => {
+        const result = await pool.run(task);
+        // Note, we don't use PerfLogger.async() because all tasks are submitted
+        // immediately at once and queued, while results are received progressively
+        logger_1.PerfLogger.log(`Result for task ${logger_1.default.name(task.id)}`);
+        return result;
+    };
+    return {
+        run: async () => {
+            const results = await logger_1.PerfLogger.async(`Thread pool`, async () => {
+                return Promise.all(pathnamesChunks.map((taskPathnames, taskIndex) => {
+                    return submitTask({
+                        id: taskIndex + 1,
+                        pathnames: taskPathnames,
+                    });
+                }));
+            });
+            const allResults = results.flat();
+            return (0, ssgGlobalResult_1.createGlobalSSGResult)(allResults);
+        },
+        destroy: async () => {
+            await pool.destroy();
+        },
+    };
+};
 async function executeSSG({ props, serverBundlePath, clientManifestPath, router, }) {
     const params = await (0, ssgParams_1.createSSGParams)({
         serverBundlePath,
         clientManifestPath,
         props,
     });
+    // TODO doesn't look like the appropriate place for hash router entry
     if (router === 'hash') {
         logger_1.PerfLogger.start('Generate Hash Router entry point');
         const content = await (0, ssgTemplate_1.renderHashRouterTemplate)({ params });
@@ -26,9 +136,12 @@ async function executeSSG({ props, serverBundlePath, clientManifestPath, router,
         logger_1.PerfLogger.end('Generate Hash Router entry point');
         return { collectedData: {} };
     }
-    const ssgResult = await logger_1.PerfLogger.async('Generate static files', () => (0, ssg_1.generateStaticFiles)({
-        pathnames: props.routesPaths,
-        params,
-    }));
-    return ssgResult;
+    const createExecutor = props.siteConfig.future.experimental_faster
+        .ssgWorkerThreads
+        ? createPooledSSGExecutor
+        : createSimpleSSGExecutor;
+    const executor = await createExecutor({ params, pathnames: props.routesPaths });
+    const result = await executor.run();
+    await executor.destroy();
+    return result;
 }

package/lib/ssg/ssgGlobalResult.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { SSGResult } from './ssgRenderer';
+import type { SiteCollectedData } from '../common';
+export type SSGGlobalResult = {
+    collectedData: SiteCollectedData;
+};
+export declare function createGlobalSSGResult(ssgResults: SSGResult[]): Promise<SSGGlobalResult>;

package/lib/ssg/ssgGlobalResult.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlobalSSGResult = createGlobalSSGResult;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+function printSSGWarnings(results) {
+    // Escape hatch because SWC is quite aggressive to report errors
+    // See https://github.com/facebook/docusaurus/pull/10554
+    // See https://github.com/swc-project/swc/discussions/9616#discussioncomment-10846201
+    if (process.env.DOCUSAURUS_IGNORE_SSG_WARNINGS === 'true') {
+        return;
+    }
+    const ignoredWarnings = [
+        // TODO Docusaurus v4: remove with React 19 upgrade
+        //  React 18 emit NULL chars, and minifier detects it
+        //  see https://github.com/facebook/docusaurus/issues/9985
+        'Unexpected null character',
+    ];
+    const keepWarning = (warning) => {
+        return !ignoredWarnings.some((iw) => warning.includes(iw));
+    };
+    const resultsWithWarnings = results
+        .map((success) => {
+        return {
+            ...success,
+            warnings: success.result.warnings.filter(keepWarning),
+        };
+    })
+        .filter((result) => result.warnings.length > 0);
+    if (resultsWithWarnings.length) {
+        const message = `Docusaurus static site generation process emitted warnings for ${resultsWithWarnings.length} path${resultsWithWarnings.length ? 's' : ''}
+This is non-critical and can be disabled with DOCUSAURUS_IGNORE_SSG_WARNINGS=true
+Troubleshooting guide: https://github.com/facebook/docusaurus/discussions/10580
+
+- ${resultsWithWarnings
+            .map((result) => `${logger_1.default.path(result.pathname)}:
+  - ${result.warnings.join('\n  - ')}
+`)
+            .join('\n- ')}`;
+        logger_1.default.warn(message);
+    }
+}
+function throwSSGError(ssgErrors) {
+    const message = `Docusaurus static site generation failed for ${ssgErrors.length} path${ssgErrors.length ? 's' : ''}:\n- ${ssgErrors
+        .map((ssgError) => logger_1.default.path(ssgError.pathname))
+        .join('\n- ')}`;
+    // Note logging this error properly require using inspect(error,{depth})
+    // See https://github.com/nodejs/node/issues/51637
+    throw new Error(message, {
+        cause: new AggregateError(ssgErrors.map((ssgError) => ssgError.error)),
+    });
+}
+async function createGlobalSSGResult(ssgResults) {
+    const [ssgSuccesses, ssgErrors] = lodash_1.default.partition(ssgResults, (result) => result.success);
+    // For now, only success results emit warnings
+    // For errors, we throw without warnings
+    printSSGWarnings(ssgSuccesses);
+    if (ssgErrors.length > 0) {
+        throwSSGError(ssgErrors);
+    }
+    // If we only have SSG successes, we can consolidate those in a single result
+    const collectedData = lodash_1.default.chain(ssgSuccesses)
+        .keyBy((success) => success.pathname)
+        .mapValues((ssgSuccess) => ssgSuccess.result.collectedData)
+        .value();
+    return { collectedData };
+}

package/lib/ssg/ssgParams.d.ts

@@ -20,6 +20,7 @@ export type SSGParams = {
     htmlMinifierType: HtmlMinifierType;
     serverBundlePath: string;
     ssgTemplateContent: string;
+    v4RemoveLegacyPostBuildHeadAttribute: boolean;
 };
 export declare function createSSGParams({ props, serverBundlePath, clientManifestPath, }: {
     props: Props;

package/lib/ssg/ssgParams.js

@@ -30,6 +30,7 @@ async function createSSGParams({ props, serverBundlePath, clientManifestPath, })
             .swcHtmlMinimizer
             ? 'swc'
             : 'terser',
+        v4RemoveLegacyPostBuildHeadAttribute: props.siteConfig.future.v4.removeLegacyPostBuildHeadAttribute,
     };
     // Useless but ensures that SSG params remain serializable
     return structuredClone(params);