module-federation-angular-adapter 0.2200.0

package/src/builders/build/builder.js

@@ -0,0 +1,413 @@
+import "./setup-builder-env-variables.js";
+import * as fs from "fs";
+import * as mrmime from "mrmime";
+import * as path from "path";
+import { buildApplication, } from "@angular/build";
+import { buildApplicationInternal, normalizeDevServerOptions, serveWithVite, SourceFileCache, } from "@angular/build/private";
+import { createBuilder, targetFromTargetString, } from "@angular-devkit/architect";
+import { createFederationCache, getExternals, normalizeFederationOptions, } from "@softarc/native-federation";
+import { AbortedError, createNfWatcher, getDefaultCachePath, logger, RebuildQueue, setLogLevel, syncNfFileWatcher, } from "@softarc/native-federation/internal";
+import { checkForInvalidImports } from "./../../utils/check-for-invalid-imports.js";
+import { federationBuildNotifier } from "./federation-build-notifier.js";
+import { createMfFederationBuilder, } from "../../tools/mf/build-for-federation.js";
+import { getI18nConfig, translateFederationArtifacts } from "./i18n.js";
+import { updateScriptTags } from "./update-index-html.js";
+const originalWrite = process.stderr.write.bind(process.stderr);
+process.stderr.write = function (chunk, encodingOrCallback, callback) {
+    const str = typeof chunk === "string" ? chunk : chunk.toString();
+    if (str.includes("vite:import-analysis") &&
+        str.includes("es-module-shims.js")) {
+        return true;
+    }
+    if (typeof encodingOrCallback !== "string") {
+        return originalWrite(chunk, encodingOrCallback);
+    }
+    return originalWrite(chunk, encodingOrCallback, callback);
+};
+const createInternalAngularBuilder = (externals, opts) => (options, context, pluginsOrExtensions) => {
+    let extensions;
+    if (pluginsOrExtensions && Array.isArray(pluginsOrExtensions)) {
+        extensions = {
+            codePlugins: pluginsOrExtensions,
+        };
+    }
+    else {
+        extensions = pluginsOrExtensions;
+    }
+    // serveWithVite fetches its own browserOptions independently, so ngBuilderOptions
+    // modifications don't reach here. Add NF externals to externalDependencies so
+    // Angular routes them to optimizeDeps.exclude, preventing Vite from trying to
+    // pre-bundle packages that include native .node binaries.
+    options.externalDependencies = [
+        ...(options.externalDependencies ?? []),
+        ...externals,
+    ];
+    if (opts?.instrumentForCoverage) {
+        options.instrumentForCoverage = opts.instrumentForCoverage;
+    }
+    // Todo: share cache with Angular builder: https://github.com/angular/angular-cli/pull/32527
+    // options.codeBundleCache = nfOptions.federationCache.bundlerCache;
+    return buildApplicationInternal(options, context, extensions);
+};
+export async function* runBuilder(nfBuilderOptions, context) {
+    let target = targetFromTargetString(nfBuilderOptions.target);
+    let targetOptions = (await context.getTargetOptions(target));
+    let builder = await context.getBuilderNameForTarget(target);
+    if (builder === "@angular-devkit/build-angular:browser-esbuild") {
+        logger.info(".: NATIVE FEDERATION - UPDATE NEEDED :.");
+        logger.info("");
+        logger.info("Since version 17.1, Native Federation uses Angular's");
+        logger.info("Application-Builder and its Dev-Server.");
+        logger.info("");
+        logger.info("If you are sill on Angular 17.0.x, please update to");
+        logger.info("Angular 17.1.x or downgrade to Native Federation 17.0.x.");
+        logger.info("");
+        logger.info("For working with Native Federation 17.1.x (recommented), ");
+        logger.info("please update your project config, e.g. in angular.json");
+        logger.info("");
+        logger.info("This command performs the needed update for default configs:");
+        logger.info("");
+        logger.info("\tng g @angular-architects/native-federation:appbuilder");
+        logger.info("");
+        logger.info("You need to run it once per application to migrate");
+        logger.info("Please find more information here: https://shorturl.at/gADJW");
+        return;
+    }
+    /**
+     * Explicitly defined as devServer or if the target contains "serve"
+     */
+    const runViteServer = typeof nfBuilderOptions.devServer !== "undefined"
+        ? !!nfBuilderOptions.devServer
+        : target.target.includes("serve");
+    let ngBuilderOptions = (await context.validateOptions(runViteServer
+        ? {
+            ...targetOptions,
+            port: nfBuilderOptions.port || targetOptions["port"],
+        }
+        : targetOptions, builder));
+    let serverOptions = null;
+    const watch = nfBuilderOptions.watch ?? ngBuilderOptions.watch ?? runViteServer;
+    ngBuilderOptions.watch = watch;
+    if (ngBuilderOptions["buildTarget"]) {
+        serverOptions = await normalizeDevServerOptions(context, context.target.project, ngBuilderOptions);
+        target = targetFromTargetString(ngBuilderOptions["buildTarget"]);
+        targetOptions = (await context.getTargetOptions(target));
+        builder = await context.getBuilderNameForTarget(target);
+        ngBuilderOptions = (await context.validateOptions(targetOptions, builder));
+    }
+    if (nfBuilderOptions.baseHref) {
+        ngBuilderOptions.baseHref = nfBuilderOptions.baseHref;
+    }
+    if (nfBuilderOptions.outputPath) {
+        ngBuilderOptions.outputPath = nfBuilderOptions.outputPath;
+    }
+    const federationTsConfig = !!nfBuilderOptions.tsConfig && nfBuilderOptions.tsConfig.length > 0
+        ? nfBuilderOptions.tsConfig
+        : ngBuilderOptions.tsConfig;
+    setLogLevel(ngBuilderOptions.verbose ? "verbose" : "info");
+    if (!ngBuilderOptions.outputPath) {
+        ngBuilderOptions.outputPath = `dist/${context.target.project}`;
+    }
+    const outputPath = ngBuilderOptions.outputPath;
+    const outputOptions = {
+        browser: "browser",
+        server: "server",
+        media: "media",
+        ...(typeof outputPath === "string" ? undefined : outputPath),
+        base: typeof outputPath === "string" ? outputPath : outputPath.base,
+    };
+    const i18n = await getI18nConfig(context);
+    const localeFilter = getLocaleFilter(ngBuilderOptions, runViteServer);
+    const sourceLocaleSegment = typeof i18n?.sourceLocale === "string"
+        ? i18n.sourceLocale
+        : i18n?.sourceLocale?.subPath || i18n?.sourceLocale?.code || "";
+    const browserOutputPath = path.join(outputOptions.base, outputOptions.browser, ngBuilderOptions.localize ? sourceLocaleSegment : "");
+    const differentDevServerOutputPath = Array.isArray(localeFilter) && localeFilter.length === 1;
+    const devServerOutputPath = !differentDevServerOutputPath
+        ? browserOutputPath
+        : path.join(outputOptions.base, outputOptions.browser, localeFilter[0]);
+    const entryPoints = nfBuilderOptions.entryPoints && nfBuilderOptions.entryPoints.length > 0
+        ? nfBuilderOptions.entryPoints
+        : [path.join(path.dirname(federationTsConfig), "src/main.ts")];
+    const cachePath = getDefaultCachePath(context.workspaceRoot);
+    const normalized = await normalizeFederationOptions({
+        projectName: nfBuilderOptions.projectName,
+        workspaceRoot: context.workspaceRoot,
+        outputPath: browserOutputPath,
+        federationConfig: inferConfigPath(federationTsConfig, context.workspaceRoot, nfBuilderOptions.federationConfigPath),
+        tsConfig: federationTsConfig,
+        verbose: ngBuilderOptions.verbose,
+        watch: ngBuilderOptions.watch,
+        dev: !!nfBuilderOptions.dev,
+        entryPoints,
+        buildNotifications: nfBuilderOptions.buildNotifications,
+        cacheExternalArtifacts: nfBuilderOptions.cacheExternalArtifacts !== false,
+    }, createFederationCache(cachePath, new SourceFileCache(cachePath)));
+    checkForInvalidImports(Object.values(normalized.config.sharedMappings), "shared mappings");
+    checkForInvalidImports(Object.keys(normalized.config.shared), "externals");
+    const start = process.hrtime();
+    logger.measure(start, "To load the federation config.");
+    const externals = getExternals(normalized.config);
+    // MF side builder (M2.1) — replaces NF's adapter + buildForFederation/rebuildForFederation.
+    const mfBuilder = await createMfFederationBuilder(normalized.config, normalized.options, externals, {
+        builderOptions: {
+            ...ngBuilderOptions,
+            plugins: nfBuilderOptions.plugins,
+            instrumentForCoverage: nfBuilderOptions.instrumentForCoverage,
+        },
+        context,
+    });
+    const plugins = [
+        {
+            name: "externals",
+            setup(build) {
+                if (build.initialOptions.platform !== "node") {
+                    build.initialOptions.external = externals.filter((e) => e !== "tslib");
+                }
+            },
+        },
+        // Inject custom esbuild plugins
+        ...(Array.isArray(nfBuilderOptions.plugins)
+            ? nfBuilderOptions.plugins
+            : []),
+    ];
+    const isLocalDevelopment = runViteServer && nfBuilderOptions.dev;
+    // Initialize SSE reloader only for local development
+    if (isLocalDevelopment && nfBuilderOptions.buildNotifications?.enable) {
+        federationBuildNotifier.initialize(nfBuilderOptions.buildNotifications.endpoint);
+    }
+    const middleware = [
+        ...(isLocalDevelopment
+            ? [
+                federationBuildNotifier.createEventMiddleware((req) => removeBaseHref(req, ngBuilderOptions.baseHref)),
+            ]
+            : []),
+        (req, res, next) => {
+            const rawUrl = removeBaseHref(req, ngBuilderOptions.baseHref);
+            const url = new URL(rawUrl || "/", "http://localhost").pathname;
+            const fileName = path.join(normalized.options.workspaceRoot, devServerOutputPath, url);
+            const exists = fs.existsSync(fileName);
+            if (url !== "/" && url !== "" && exists) {
+                const lookup = mrmime.lookup;
+                const mimeType = lookup(path.extname(fileName)) || "text/javascript";
+                const rawBody = fs.readFileSync(fileName, "utf-8");
+                // TODO: Evaluate need for debug infos
+                // const body = addDebugInformation(url, rawBody);
+                const body = rawBody;
+                res.writeHead(200, {
+                    "Content-Type": mimeType,
+                    "Access-Control-Allow-Origin": "*",
+                    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE",
+                    "Access-Control-Allow-Headers": "Content-Type",
+                });
+                res.end(body);
+            }
+            else {
+                next();
+            }
+        },
+    ];
+    let first = true;
+    const nfWatcher = watch
+        ? createNfWatcher()
+        : undefined;
+    if (nfWatcher) {
+        nfWatcher.addPaths(path.dirname(path.resolve(context.workspaceRoot, federationTsConfig)));
+    }
+    if (fs.existsSync(normalized.options.outputPath)) {
+        fs.rmSync(normalized.options.outputPath, { recursive: true });
+    }
+    if (!fs.existsSync(normalized.options.outputPath)) {
+        fs.mkdirSync(normalized.options.outputPath, { recursive: true });
+    }
+    let federationResult;
+    try {
+        federationResult = await mfBuilder.build();
+    }
+    catch (e) {
+        logger.error(e?.message ?? "Building the artifacts failed");
+        process.exit(1);
+    }
+    // Dispose the finished federation context so its compiler-plugin onDispose resets
+    // Angular's shared TS compilation state before the app build (#47); watch reuses it.
+    if (!watch) {
+        await mfBuilder.dispose().catch(() => undefined);
+    }
+    if (nfWatcher) {
+        syncNfFileWatcher(nfWatcher, normalized.options.federationCache.bundlerCache);
+    }
+    const hasLocales = i18n?.locales && Object.keys(i18n.locales).length > 0;
+    if (hasLocales && localeFilter) {
+        const start = process.hrtime();
+        translateFederationArtifacts(i18n, localeFilter, outputOptions.base, toFederationInfoForI18n(federationResult));
+        logger.measure(start, "To translate the artifacts.");
+    }
+    ngBuilderOptions.deleteOutputPath = false;
+    const appBuilderName = "@angular/build:application";
+    const builderRun = runViteServer
+        ? serveWithVite(serverOptions, appBuilderName, createInternalAngularBuilder(externals, {
+            instrumentForCoverage: nfBuilderOptions.instrumentForCoverage,
+        }), context, nfBuilderOptions.skipHtmlTransform
+            ? {}
+            : { indexHtml: transformIndexHtml(nfBuilderOptions) }, {
+            buildPlugins: plugins,
+            middleware,
+        })
+        : buildApplication({
+            ...ngBuilderOptions,
+            ...(nfBuilderOptions.instrumentForCoverage
+                ? { instrumentForCoverage: nfBuilderOptions.instrumentForCoverage }
+                : {}),
+        }, context, {
+            codePlugins: plugins,
+            indexHtmlTransformer: transformIndexHtml(nfBuilderOptions),
+        });
+    const rebuildQueue = new RebuildQueue();
+    const builderIterator = builderRun[Symbol.asyncIterator]();
+    let ngBuildStatus = { success: false };
+    try {
+        let buildResult = await builderIterator.next();
+        while (!buildResult.done) {
+            if (buildResult.value)
+                ngBuildStatus = buildResult.value;
+            if (!ngBuildStatus.success) {
+                logger.warn("Skipping federation artifacts because Angular build failed.");
+                buildResult = await builderIterator.next();
+            }
+            else if (!first && watch) {
+                const nextOutputPromise = builderIterator.next();
+                const trackResult = await rebuildQueue.track(async (signal) => {
+                    try {
+                        if (signal?.aborted) {
+                            throw new AbortedError("Build canceled before starting");
+                        }
+                        await new Promise((resolve, reject) => {
+                            const timeout = setTimeout(resolve, Math.max(10, nfBuilderOptions.rebuildDelay));
+                            if (signal) {
+                                const abortHandler = () => {
+                                    clearTimeout(timeout);
+                                    reject(new AbortedError("[builder] During delay."));
+                                };
+                                signal.addEventListener("abort", abortHandler, {
+                                    once: true,
+                                });
+                            }
+                        });
+                        if (signal?.aborted) {
+                            throw new AbortedError("[builder] Before federation build.");
+                        }
+                        // Invalidate only files that changed since the last rebuild, falling back to all
+                        // source files when the buffer is empty (e.g. first watch rebuild). Unlike the
+                        // remote builder, the buffer is cleared eagerly here because Angular's iterator —
+                        // not this buffer — re-triggers the next rebuild.
+                        const changedFiles = nfWatcher ? [...nfWatcher.get()] : [];
+                        if (nfWatcher)
+                            nfWatcher.clear();
+                        federationResult = await mfBuilder.rebuild(changedFiles);
+                        if (nfWatcher) {
+                            syncNfFileWatcher(nfWatcher, normalized.options.federationCache.bundlerCache);
+                        }
+                        if (signal?.aborted) {
+                            throw new AbortedError("[builder] After federation build.");
+                        }
+                        if (hasLocales && localeFilter) {
+                            translateFederationArtifacts(i18n, localeFilter, outputOptions.base, toFederationInfoForI18n(federationResult));
+                        }
+                        if (signal?.aborted) {
+                            throw new AbortedError("[builder] After federation translations.");
+                        }
+                        logger.info("Done!");
+                        if (isLocalDevelopment) {
+                            federationBuildNotifier.broadcastBuildCompletion();
+                        }
+                        return { success: true };
+                    }
+                    catch (error) {
+                        if (error instanceof AbortedError) {
+                            logger.verbose("Rebuild was canceled. Cancellation point: " + error?.message);
+                            federationBuildNotifier.broadcastBuildCancellation();
+                            return { success: false, cancelled: true };
+                        }
+                        logger.error("Federation rebuild failed!");
+                        if (ngBuilderOptions.verbose)
+                            console.error(error);
+                        if (isLocalDevelopment) {
+                            federationBuildNotifier.broadcastBuildError(error);
+                        }
+                        return { success: false };
+                    }
+                }, nextOutputPromise);
+                // Same trackResult shape as the remote builder, plus the iterator pump:
+                // the 'interrupted' branch feeds Angular's next output back into the loop
+                // (the remote builder has no iterator, so it just loops on its watcher).
+                if (trackResult.type === "completed") {
+                    if (!trackResult.result.cancelled) {
+                        ngBuildStatus = { success: trackResult.result.success };
+                        yield ngBuildStatus;
+                    }
+                    buildResult = await nextOutputPromise;
+                }
+                else {
+                    buildResult = trackResult.value;
+                }
+            }
+            else {
+                buildResult = await builderIterator.next();
+            }
+            first = false;
+        }
+    }
+    finally {
+        rebuildQueue.dispose();
+        await mfBuilder.dispose();
+        await nfWatcher?.close();
+        if (isLocalDevelopment) {
+            federationBuildNotifier.stopEventServer();
+        }
+    }
+    yield ngBuildStatus;
+}
+/**
+ * Transitional bridge (M2.1): feed MF artifact files to NF's i18n translator,
+ * which reads `exposes[].outFileName`. The full MF i18n rework (per-locale
+ * `mf-manifest.json` + `remoteEntry.js`) is **M4.2**; until then this maps MF's
+ * written chunk basenames onto the minimal `FederationInfo` shape the translator
+ * consumes.
+ */
+function toFederationInfoForI18n(mf) {
+    return {
+        name: mf.name,
+        shared: [],
+        exposes: mf.writtenFiles.map((f) => ({ outFileName: path.basename(f) })),
+    };
+}
+function removeBaseHref(req, baseHref) {
+    let url = req.url ?? "";
+    if (baseHref && url.startsWith(baseHref)) {
+        url = url.slice(baseHref.length);
+    }
+    return url;
+}
+function getLocaleFilter(options, runViteServer) {
+    let localize = options.localize || false;
+    if (runViteServer && Array.isArray(localize) && localize.length > 1) {
+        localize = false;
+    }
+    if (runViteServer && localize === true) {
+        localize = false;
+    }
+    return localize;
+}
+function inferConfigPath(tsConfig, workspaceRoot, federationConfigPath = "federation.config.mjs") {
+    const relProjectPath = path.dirname(tsConfig);
+    const mjsRelPath = path.join(relProjectPath, federationConfigPath);
+    if (fs.existsSync(path.resolve(workspaceRoot, mjsRelPath))) {
+        return mjsRelPath;
+    }
+    return path.join(relProjectPath, "federation.config.js");
+}
+function transformIndexHtml(nfOptions) {
+    return (content) => Promise.resolve(updateScriptTags(content, nfOptions));
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export default createBuilder(runBuilder);

package/src/builders/build/federation-build-notifier.d.ts

@@ -0,0 +1,70 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+type NextFunction = (error?: Error) => void;
+type MiddlewareFunction = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void;
+/**
+ * Manages Server-Sent Events for federation hot reload in local development
+ * Only active when running in development mode with dev server
+ */
+declare class FederationBuildNotifier {
+    private connections;
+    private cleanupInterval;
+    private isActive;
+    private endpoint;
+    /**
+     * Initializes the SSE reloader for local development
+     */
+    initialize(endpoint: string): void;
+    /**
+     * Creates SSE middleware for federation events
+     */
+    createEventMiddleware(removeBaseHref: (req: IncomingMessage) => string): MiddlewareFunction;
+    /**
+     * Sets up a new SSE connection
+     */
+    private _setupSSEConnection;
+    /**
+     * Removes a connection from the pool
+     */
+    private _removeConnection;
+    /**
+     * Broadcasts an event to all connected clients
+     * Only works in local development mode
+     */
+    private _broadcastEvent;
+    /**
+     * Sends an event to a specific response stream
+     */
+    private _sendEvent;
+    /**
+     * Starts periodic cleanup of dead connections
+     */
+    private startCleanup;
+    /**
+     * Notifies about successful federation rebuild
+     */
+    broadcastBuildCompletion(): void;
+    /**
+     * Notifies about cancellation of a federation rebuild
+     */
+    broadcastBuildCancellation(): void;
+    /**
+     * Notifies about failed federation rebuild
+     */
+    broadcastBuildError(error: unknown): void;
+    /**
+     * Stops cleanup and closes all connections
+     * Should be called when development server stops
+     */
+    stopEventServer(): void;
+    /**
+     * Returns the number of active connections
+     */
+    get activeConnections(): number;
+    /**
+     * Returns whether the reloader is active
+     */
+    get isRunning(): boolean;
+}
+export declare const federationBuildNotifier: FederationBuildNotifier;
+export {};
+//# sourceMappingURL=federation-build-notifier.d.ts.map

package/src/builders/build/federation-build-notifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"federation-build-notifier.d.ts","sourceRoot":"","sources":["../../../../src/builders/build/federation-build-notifier.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAkB5D,KAAK,YAAY,GAAG,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;AAC5C,KAAK,kBAAkB,GAAG,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;AAElG;;;GAGG;AACH,cAAM,uBAAuB;IAC3B,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,eAAe,CAA+B;IACtD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAqB;IAErC;;OAEG;IACI,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAYzC;;OAEG;IACI,qBAAqB,CAC1B,cAAc,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,MAAM,GAC/C,kBAAkB;IAgBrB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA4B3B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAUzB;;;OAGG;IACH,OAAO,CAAC,eAAe;IAyBvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB;;OAEG;IACH,OAAO,CAAC,YAAY;IAsBpB;;OAEG;IACI,wBAAwB,IAAI,IAAI;IAOvC;;OAEG;IACI,0BAA0B,IAAI,IAAI;IAOzC;;OAEG;IACI,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAQhD;;;OAGG;IACI,eAAe,IAAI,IAAI;IAuB9B;;OAEG;IACH,IAAW,iBAAiB,IAAI,MAAM,CAErC;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,OAAO,CAE9B;CACF;AAGD,eAAO,MAAM,uBAAuB,yBAAgC,CAAC"}

package/src/builders/build/federation-build-notifier.js

@@ -0,0 +1,186 @@
+import { BuildNotificationType } from '@softarc/native-federation';
+import { logger } from '@softarc/native-federation/internal';
+/**
+ * Manages Server-Sent Events for federation hot reload in local development
+ * Only active when running in development mode with dev server
+ */
+class FederationBuildNotifier {
+    connections = [];
+    cleanupInterval = null;
+    isActive = false;
+    endpoint;
+    /**
+     * Initializes the SSE reloader for local development
+     */
+    initialize(endpoint) {
+        if (this.isActive) {
+            return;
+        }
+        this.endpoint = endpoint;
+        this.isActive = true;
+        this.startCleanup();
+        logger.info(`[Federation SSE] Local reloader initialized with endpoint ${this.endpoint}`);
+    }
+    /**
+     * Creates SSE middleware for federation events
+     */
+    createEventMiddleware(removeBaseHref) {
+        if (!this.isActive) {
+            return (_req, _res, next) => next();
+        }
+        return (req, res, next) => {
+            const url = removeBaseHref(req);
+            if (url !== this.endpoint) {
+                return next();
+            }
+            this._setupSSEConnection(req, res);
+        };
+    }
+    /**
+     * Sets up a new SSE connection
+     */
+    _setupSSEConnection(req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Headers': 'Cache-Control',
+        });
+        // Send initial connection event
+        this._sendEvent(res, {
+            type: 'connected',
+            timestamp: Date.now(),
+        });
+        // Store connection
+        const connection = { response: res, request: req };
+        this.connections.push(connection);
+        // Handle disconnection
+        req.on('close', () => this._removeConnection(connection));
+        req.on('error', () => this._removeConnection(connection));
+        logger.info(`[Federation SSE] Client connected. Active connections: ${this.connections.length}`);
+    }
+    /**
+     * Removes a connection from the pool
+     */
+    _removeConnection(connection) {
+        const index = this.connections.indexOf(connection);
+        if (index !== -1) {
+            this.connections.splice(index, 1);
+            logger.info(`[Federation SSE] Client disconnected. Active connections: ${this.connections.length}`);
+        }
+    }
+    /**
+     * Broadcasts an event to all connected clients
+     * Only works in local development mode
+     */
+    _broadcastEvent(event) {
+        if (!this.isActive || this.connections.length === 0) {
+            return;
+        }
+        const deadConnections = [];
+        this.connections.forEach(connection => {
+            try {
+                this._sendEvent(connection.response, event);
+            }
+            catch {
+                deadConnections.push(connection);
+            }
+        });
+        // Remove dead connections
+        deadConnections.forEach(connection => this._removeConnection(connection));
+        if (this.connections.length > 0) {
+            logger.info(`[Federation SSE] Event '${event.type}' broadcast to ${this.connections.length} clients`);
+        }
+    }
+    /**
+     * Sends an event to a specific response stream
+     */
+    _sendEvent(res, event) {
+        const data = JSON.stringify(event);
+        res.write(`data: ${data}\n\n`);
+    }
+    /**
+     * Starts periodic cleanup of dead connections
+     */
+    startCleanup() {
+        if (this.cleanupInterval) {
+            return;
+        }
+        this.cleanupInterval = setInterval(() => {
+            const aliveBefore = this.connections.length;
+            this.connections = this.connections.filter(connection => !connection.response.destroyed &&
+                !connection.request.destroyed &&
+                connection.response.writable);
+            if (this.connections.length !== aliveBefore) {
+                logger.info(`[Federation SSE] Cleaned up ${aliveBefore - this.connections.length} dead connections`);
+            }
+        }, 30000); // Clean every 30 seconds
+    }
+    /**
+     * Notifies about successful federation rebuild
+     */
+    broadcastBuildCompletion() {
+        this._broadcastEvent({
+            type: BuildNotificationType.COMPLETED,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Notifies about cancellation of a federation rebuild
+     */
+    broadcastBuildCancellation() {
+        this._broadcastEvent({
+            type: BuildNotificationType.CANCELLED,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Notifies about failed federation rebuild
+     */
+    broadcastBuildError(error) {
+        this._broadcastEvent({
+            type: BuildNotificationType.ERROR,
+            timestamp: Date.now(),
+            error: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+    /**
+     * Stops cleanup and closes all connections
+     * Should be called when development server stops
+     */
+    stopEventServer() {
+        if (!this.isActive) {
+            return;
+        }
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.connections.forEach(connection => {
+            try {
+                connection.response.end();
+            }
+            catch {
+                // Connection might already be closed
+            }
+        });
+        this.connections = [];
+        this.isActive = false;
+        logger.info('[Federation SSE] Local reloader disposed');
+    }
+    /**
+     * Returns the number of active connections
+     */
+    get activeConnections() {
+        return this.connections.length;
+    }
+    /**
+     * Returns whether the reloader is active
+     */
+    get isRunning() {
+        return this.isActive;
+    }
+}
+// Singleton instance for local development
+export const federationBuildNotifier = new FederationBuildNotifier();