@bleedingdev/modern-js-app-tools-extensions 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

package/dist/esm-node/native-type-checker.mjs

@@ -0,0 +1,143 @@
+import "node:module";
+import { execFile } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import node_path from "node:path";
+import { promisify } from "node:util";
+import { refreshTsgoCheckerConfig } from "@modern-js/builder";
+const execute = promisify(execFile);
+const native_type_checker_name = 'UltramodernNativeTypeChecker';
+const watchDependencyPath = (file)=>{
+    if ('win32' !== process.platform) return file;
+    try {
+        return realpathSync.native(file);
+    } catch  {
+        return file;
+    }
+};
+class UltramodernNativeTypeChecker {
+    async check() {
+        const { configFile, build } = this.options;
+        if (!build) {
+            const config = JSON.parse(await this.run([
+                '--showConfig',
+                '--project',
+                configFile
+            ]));
+            if (config.references?.length) await this.run([
+                '--build',
+                ...config.references.map((reference)=>node_path.resolve(node_path.dirname(configFile), reference.path)),
+                '--stopBuildOnErrors',
+                '--pretty',
+                'false'
+            ]);
+        }
+        const args = build ? [
+            '--build',
+            configFile,
+            '--stopBuildOnErrors'
+        ] : [
+            '--project',
+            configFile,
+            '--noEmit'
+        ];
+        await this.run([
+            ...args,
+            '--pretty',
+            'false'
+        ]);
+    }
+    async run(args) {
+        try {
+            const result = await execute(this.options.compiler(), args, {
+                cwd: node_path.dirname(this.options.configFile),
+                maxBuffer: 16777216
+            });
+            return result.stdout;
+        } catch (cause) {
+            const output = cause;
+            const diagnostics = `${output.stdout ?? ''}${output.stderr ?? ''}`;
+            throw new Error(`${native_type_checker_name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}`, {
+                cause
+            });
+        }
+    }
+    async watchInputs() {
+        const inputs = new Set();
+        const missing = new Set();
+        const projects = [
+            this.options.configFile
+        ];
+        const visited = new Set();
+        for (const configFile of projects){
+            if (visited.has(configFile)) continue;
+            visited.add(configFile);
+            inputs.add(configFile);
+            if (!existsSync(configFile)) {
+                missing.add(configFile);
+                continue;
+            }
+            let config;
+            try {
+                config = JSON.parse(await this.run([
+                    '--showConfig',
+                    '--project',
+                    configFile
+                ]));
+            } catch  {
+                continue;
+            }
+            const directory = node_path.dirname(configFile);
+            for (const file of config.files ?? [])inputs.add(node_path.resolve(directory, file));
+            for (const reference of config.references ?? []){
+                const target = node_path.resolve(directory, reference.path);
+                projects.push('.json' === node_path.extname(target) ? target : node_path.join(target, 'tsconfig.json'));
+            }
+        }
+        return {
+            inputs,
+            missing
+        };
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(native_type_checker_name, (compilation)=>{
+            compilation.hooks.processAssets.tapPromise(native_type_checker_name, async ()=>{
+                try {
+                    compilation.fileDependencies.add(watchDependencyPath(this.options.configFile));
+                    const projectConfigFile = refreshTsgoCheckerConfig(this.options.configFile);
+                    if (projectConfigFile) {
+                        const watched = watchDependencyPath(projectConfigFile);
+                        compilation.fileDependencies.add(watched);
+                        if (!existsSync(projectConfigFile)) compilation.missingDependencies.add(watched);
+                    }
+                    const { inputs, missing } = await this.watchInputs();
+                    for (const file of inputs)compilation.fileDependencies.add(watchDependencyPath(file));
+                    for (const file of missing)compilation.missingDependencies.add(watchDependencyPath(file));
+                    await this.check();
+                } catch (cause) {
+                    compilation.errors.push(new Error(cause instanceof Error ? cause.message : String(cause), {
+                        cause
+                    }));
+                }
+            });
+        });
+    }
+    constructor(options){
+        this.options = options;
+    }
+}
+function configureUltramodernTypeChecker(chain, pluginId, resolveCompiler) {
+    if (!chain.plugins.has(pluginId)) return;
+    const options = chain.plugin(pluginId).get('args')?.[0];
+    const typescript = options?.typescript;
+    if (typescript?.tsgo === false) return;
+    if (!typescript?.configFile) throw new Error(`${native_type_checker_name} requires the configured TypeScript project.`);
+    const configFile = node_path.resolve(typescript.configFile);
+    chain.plugin(pluginId).use(UltramodernNativeTypeChecker, [
+        {
+            build: true === typescript.build,
+            compiler: ()=>resolveCompiler(configFile),
+            configFile
+        }
+    ]);
+}
+export { UltramodernNativeTypeChecker, configureUltramodernTypeChecker };

package/dist/esm-node/policy-defaults.mjs

@@ -0,0 +1,46 @@
+import "node:module";
+import { collectRuntimePackageModuleDirectories, createRuntimePackageResolutionPlugin } from "./runtime-package-resolution.mjs";
+const RENDERER_EXTENSIONS_PACKAGE = '@modern-js/runtime-renderer-extensions';
+const RENDERER_EXTENSIONS_PLUGIN_NAME = 'rendererHead';
+const SERVER_EXTENSIONS_PLUGIN_NAME = '@modern-js/app-tools/server-plugin';
+const POLICY_DEFAULTS_PLUGIN_NAME = '@modern-js/ultramodern-policy-defaults';
+const applyPolicyDefaults = (api, options = {})=>{
+    if (false !== options.rendererExtensions) {
+        api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+            if (!plugins.some((plugin)=>plugin.path === RENDERER_EXTENSIONS_PACKAGE)) plugins.push({
+                name: RENDERER_EXTENSIONS_PLUGIN_NAME,
+                path: RENDERER_EXTENSIONS_PACKAGE,
+                config: {}
+            });
+            return {
+                entrypoint,
+                plugins
+            };
+        });
+        const moduleDirectories = collectRuntimePackageModuleDirectories([
+            RENDERER_EXTENSIONS_PACKAGE
+        ], import.meta.url);
+        if (moduleDirectories.length > 0) api.modifyResolvedConfig((config)=>({
+                ...config,
+                builderPlugins: [
+                    ...config.builderPlugins ?? [],
+                    createRuntimePackageResolutionPlugin(moduleDirectories)
+                ]
+            }));
+    }
+    if (false !== options.serverExtensions) api._internalServerPlugins(({ plugins })=>{
+        if (!plugins.some((plugin)=>plugin.name === SERVER_EXTENSIONS_PLUGIN_NAME)) plugins.push({
+            name: SERVER_EXTENSIONS_PLUGIN_NAME
+        });
+        return {
+            plugins
+        };
+    });
+};
+const createPolicyDefaultsPlugin = (options = {})=>({
+        name: POLICY_DEFAULTS_PLUGIN_NAME,
+        setup (api) {
+            applyPolicyDefaults(api, options);
+        }
+    });
+export { POLICY_DEFAULTS_PLUGIN_NAME, RENDERER_EXTENSIONS_PACKAGE, RENDERER_EXTENSIONS_PLUGIN_NAME, SERVER_EXTENSIONS_PLUGIN_NAME, applyPolicyDefaults, createPolicyDefaultsPlugin };

package/dist/esm-node/release-envelope/framework-output.mjs

@@ -2,7 +2,7 @@ import "node:module";
 import { createHash } from "node:crypto";
 import promises from "node:fs/promises";
 import node_path from "node:path";
-import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, isUltramodernBuildArtifact } from "@modern-js/utils/universal";
+import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, isUltramodernBuildArtifact } from "@modern-js/backend-federation-contracts";
 import { canonicalSerializeMicroVerticalReleaseEnvelope, createMicroVerticalReleaseEnvelope, verifyMicroVerticalReleaseEnvelope } from "./index.mjs";
 const MICROVERTICAL_RELEASE_ENVELOPE_PATH = 'release/microvertical-release-envelope.json';
 const MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_PATH = 'release/microvertical-release-identity-carriers.json';
@@ -22,6 +22,46 @@ const collectNestedStrings = (value, key)=>{
             ...collectNestedStrings(entryValue, key)
         ]);
 };
+const emptyProducerRouteModules = async (distDirectory, files, manifest, manifestLogicalPath)=>{
+    if (!isRecord(manifest) || !Array.isArray(manifest.exposes) || 0 !== manifest.exposes.length || !Array.isArray(manifest.remotes) || 0 !== manifest.remotes.length || !isRecord(manifest.metaData) || !isRecord(manifest.metaData.remoteEntry) || '' !== manifest.metaData.remoteEntry.name || '' !== manifest.metaData.remoteEntry.path || 'global' !== manifest.metaData.remoteEntry.type) return [];
+    const publicPath = manifest.metaData.publicPath;
+    const safeReference = (value)=>'string' == typeof value && value.length > 0 && !/[\\\\%?#\s]/u.test(value) && !value.split('/').some((segment)=>'.' === segment || '..' === segment);
+    if (!safeReference(publicPath)) return [];
+    const absoluteBase = /^https?:\/\//u.test(publicPath);
+    if ('auto' !== publicPath && (!publicPath.endsWith('/') || !absoluteBase && (!publicPath.startsWith('/') || publicPath.startsWith('//')))) return [];
+    if (absoluteBase) {
+        const base = new URL(publicPath);
+        if (base.username || base.password || base.href !== publicPath) return [];
+    }
+    const directory = node_path.posix.dirname(manifestLogicalPath);
+    const routesManifest = await readJson(node_path.join(distDirectory, directory, 'routes-manifest.json'));
+    if (!isRecord(routesManifest) || !isRecord(routesManifest.routeAssets)) return [];
+    const modules = new Set();
+    for (const route of Object.values(routesManifest.routeAssets)){
+        if (!isRecord(route) || !Array.isArray(route.assets)) return [];
+        for (const reference of route.assets){
+            if (!safeReference(reference) || reference.startsWith('//')) return [];
+            let relative = reference;
+            if (/^https?:\/\//u.test(reference)) {
+                if (!absoluteBase || !reference.startsWith(publicPath)) return [];
+                relative = reference.slice(publicPath.length);
+            } else if (reference.startsWith('/')) {
+                const prefix = 'auto' === publicPath ? '/' : absoluteBase ? new URL(publicPath).pathname : publicPath;
+                if (!reference.startsWith(prefix)) return [];
+                relative = reference.slice(prefix.length);
+            }
+            if (!/^(?:static|html|public)\/[^:]+$/u.test(relative) || relative.includes('//')) return [];
+            const logicalPath = node_path.posix.join(directory, relative);
+            if (!files.includes(logicalPath)) return [];
+            const assetStat = await promises.lstat(node_path.join(distDirectory, logicalPath));
+            if (!assetStat.isFile()) return [];
+            if (COMPILED_MODULE_PATTERN.test(logicalPath)) modules.add(logicalPath);
+        }
+    }
+    return [
+        ...modules
+    ];
+};
 const manifestReferencedClientModules = async (distDirectory, files, manifestLogicalPath = 'mf-manifest.json')=>{
     const manifest = await readJson(node_path.join(distDirectory, manifestLogicalPath));
     const references = [
@@ -31,9 +71,10 @@ const manifestReferencedClientModules = async (distDirectory, files, manifestLog
         ...collectNestedStrings(manifest, 'async')
     ];
     const normalizedReferences = new Set(references.filter((value)=>'string' == typeof value).map((value)=>value.replace(/^https?:\/\/[^/]+/u, '')).map((value)=>value.replace(/^\/+/u, '')));
-    return files.filter((logicalPath)=>COMPILED_MODULE_PATTERN.test(logicalPath) && [
+    const modules = files.filter((logicalPath)=>COMPILED_MODULE_PATTERN.test(logicalPath) && [
             ...normalizedReferences
         ].some((reference)=>reference === logicalPath || reference.endsWith(`/${logicalPath}`) || logicalPath.endsWith(`/${reference}`)));
+    return modules.length > 0 ? modules : emptyProducerRouteModules(distDirectory, files, manifest, manifestLogicalPath);
 };
 const routeReferencedSsrModules = async (distDirectory, files, target, routeSpecLogicalPath = 'route.json')=>{
     const routeSpec = await readJson(node_path.join(distDirectory, routeSpecLogicalPath));
@@ -83,11 +124,14 @@ const writeReleaseEnvelope = async (artifactRoot, envelope)=>{
     if (!envelopePath) throw new Error('[ultramodern-release-envelope] could not resolve release envelope path.');
     await promises.writeFile(envelopePath, `${canonicalSerializeMicroVerticalReleaseEnvelope(envelope)}\n`);
 };
-const readBuildArtifact = async (distDirectory)=>{
+const readBuildArtifact = async (distDirectory, requirePromotable = true)=>{
     const artifactPath = node_path.join(distDirectory, ULTRAMODERN_BUILD_ARTIFACT_FILE);
     const artifact = await readJson(artifactPath);
     if (!isUltramodernBuildArtifact(artifact)) throw new Error(`[ultramodern-release-envelope] ${ULTRAMODERN_BUILD_ARTIFACT_FILE} is missing or invalid.`);
-    if ('workspace' === artifact.deliveryUnit.sourceRevision) throw new Error('[ultramodern-release-envelope] sourceRevision "workspace" cannot produce a promotable full-stack envelope.');
+    if ('workspace' === artifact.deliveryUnit.sourceRevision) {
+        if (!requirePromotable) return;
+        throw new Error('[ultramodern-release-envelope] sourceRevision "workspace" cannot produce a promotable full-stack envelope.');
+    }
     return artifact;
 };
 const assertIdentityBlock = (value, identity, location, includeReleaseVersion)=>{
@@ -285,7 +329,7 @@ const pathExists = async (filePath)=>{
         return false;
     }
 };
-const emitFrameworkMicroVerticalReleaseEnvelope = async ({ apiOnly, distDirectory, target })=>{
+const emitFrameworkMicroVerticalReleaseEnvelope = async ({ apiOnly, distDirectory, requirePromotable = true, target })=>{
     if (apiOnly) return;
     const backendManifestPath = node_path.join(distDirectory, BACKEND_FEDERATION_MANIFEST_FILE);
     const backendContainerPath = node_path.join(distDirectory, BACKEND_FEDERATION_REMOTE_ENTRY_FILE);
@@ -295,7 +339,8 @@ const emitFrameworkMicroVerticalReleaseEnvelope = async ({ apiOnly, distDirector
     ]);
     if (!hasBackendManifest && !hasBackendContainer) return;
     if (!hasBackendManifest || !hasBackendContainer) throw new Error('[ultramodern-release-envelope] full-stack MicroVertical backend federation manifest and container must be emitted together.');
-    const buildArtifact = await readBuildArtifact(distDirectory);
+    const buildArtifact = await readBuildArtifact(distDirectory, requirePromotable);
+    if (!buildArtifact) return;
     const identity = {
         unitId: buildArtifact.deliveryUnit.unitId,
         buildMarker: buildArtifact.deliveryUnit.buildMarker,

package/dist/esm-node/release-envelope/plugin.mjs

@@ -11,24 +11,26 @@ const createUltramodernReleaseEnvelopePlugin = ({ resolveDeployTarget })=>({
         name: '@modern-js/ultramodern-release-envelope',
         pre: [
             '@modern-js/backend-federation-build',
-            '@modern-js/plugin-bff'
+            '@modern-js/plugin-bff',
+            '@modern-js/deploy-output-aliases'
         ],
         post: [
             '@modern-js/plugin-deploy'
         ],
         setup (api) {
-            const emitBuildEnvelope = async (target)=>{
+            const emitBuildEnvelope = async (target, requirePromotable = true)=>{
                 const { apiOnly, distDirectory } = api.getAppContext();
                 await emitFrameworkMicroVerticalReleaseEnvelope({
                     apiOnly,
                     distDirectory,
+                    requirePromotable,
                     target
                 });
             };
             api.onAfterBuild(async ()=>{
                 const configuredTarget = resolveDeployTarget(api.getNormalizedConfig());
                 if ('node' !== configuredTarget && 'cloudflare' !== configuredTarget) return;
-                await emitBuildEnvelope(configuredTarget);
+                await emitBuildEnvelope(configuredTarget, false);
             });
             api.onBeforeDeploy(async ()=>{
                 const configuredTarget = resolveActiveDeployTarget(api, resolveDeployTarget);

package/dist/esm-node/release-identity.mjs

@@ -5,11 +5,8 @@ const BUILD_MARKER_NAMESPACE = 'ultramodern-delivery-unit-release-build-marker:v
 const PROMOTABLE_SOURCE_REVISION_PATTERN = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u;
 const gitOutput = (workspaceRoot, args)=>{
     try {
-        return execFileSync('git', [
-            '-C',
-            workspaceRoot,
-            ...args
-        ], {
+        return execFileSync('git', args, {
+            cwd: workspaceRoot,
             encoding: 'utf8',
             stdio: [
                 'ignore',
@@ -44,7 +41,7 @@ const resolveUltramodernSourceRevision = (workspaceRoot = process.cwd(), configu
     ]);
     const status = gitOutput(gitRoot, [
         'status',
-        '--porcelain=v1',
+        '--porcelain',
         '--untracked-files=all'
     ]);
     if (!revision || void 0 === status || status.length > 0) return 'workspace';

package/dist/esm-node/runtime-package-resolution.mjs

@@ -0,0 +1,61 @@
+import "node:module";
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+const findHostingModuleDirectory = (packageName, fromDirectory)=>{
+    let directory = node_path.resolve(fromDirectory);
+    for(;;){
+        const candidate = node_path.join(directory, 'node_modules');
+        if (node_fs.existsSync(node_path.join(candidate, packageName))) return candidate;
+        const parent = node_path.dirname(directory);
+        if (parent === directory) return;
+        directory = parent;
+    }
+};
+const collectRuntimePackageModuleDirectories = (packageNames, registrarUrl)=>{
+    const registrarDirectory = node_path.dirname(fileURLToPath(registrarUrl));
+    const directories = [];
+    for (const packageName of packageNames){
+        const directory = findHostingModuleDirectory(packageName, registrarDirectory);
+        if (directory && !directories.includes(directory)) directories.push(directory);
+    }
+    return directories;
+};
+const appendModuleDirectories = (config, directories)=>{
+    if (0 === directories.length) return;
+    config.resolve ??= {};
+    const existing = config.resolve.modules ?? [
+        'node_modules'
+    ];
+    config.resolve.modules = [
+        ...existing,
+        ...directories.filter((directory)=>!existing.includes(directory))
+    ];
+};
+const createRuntimePackageResolutionPlugin = (directories)=>({
+        name: 'ultramodern:runtime-package-resolution',
+        setup (api) {
+            api.modifyRspackConfig({
+                order: 'post',
+                handler (config) {
+                    appendModuleDirectories(config, directories);
+                }
+            });
+            api.onBeforeCreateCompiler({
+                order: 'post',
+                handler ({ bundlerConfigs }) {
+                    for (const config of bundlerConfigs)appendModuleDirectories(config, directories);
+                }
+            });
+        }
+    });
+const canResolveRuntimePackage = (packageName, registrarUrl)=>{
+    try {
+        createRequire(registrarUrl).resolve(packageName);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+export { canResolveRuntimePackage, collectRuntimePackageModuleDirectories, createRuntimePackageResolutionPlugin, findHostingModuleDirectory };

package/dist/types/backend-federation-build/codegen.d.ts

@@ -0,0 +1,86 @@
+import type { BackendFederationEntryIntegrity } from '@modern-js/server-runtime-extensions/backend-federation-security';
+import { type BackendFederationApp } from './config.js';
+export declare const createBackendRemoteEntrySource: (workspaceRoot: string, app: BackendFederationApp, effectApiPath: string, entryPath: string) => Promise<string>;
+export declare const createBackendManifest: (workspaceRoot: string, distDirectory: string, app: BackendFederationApp, entryIntegrity: BackendFederationEntryIntegrity) => {
+    schemaVersion: number;
+    id: string;
+    name: string;
+    version: string | undefined;
+    buildVersion: string | undefined;
+    metaData: {
+        name: string;
+        type: string;
+        buildInfo: {
+            buildVersion: string | undefined;
+            buildName: string | undefined;
+        };
+        remoteEntry: {
+            name: string;
+            path: string;
+            type: string;
+        };
+        globalName: string;
+        publicPath: string;
+        ssrRemoteEntry: {
+            name: string;
+            path: string;
+            type: string;
+        };
+        ssrPublicPath: string;
+    };
+    entry: {
+        byteLength: number;
+        sha256: string;
+        file: string;
+        path: string;
+        type: string;
+        url: string;
+    };
+    exposes: {
+        id: string;
+        name: string;
+        path: string;
+        assets: {
+            js: {
+                async: never[];
+                sync: string[];
+            };
+            css: {
+                async: never[];
+                sync: never[];
+            };
+        };
+    }[];
+    shared: never[];
+    backendFederation: {
+        role: string;
+        appId: string;
+        name: string;
+        runtimeFramework: string;
+        strictEffectApproach: boolean;
+        contractVersion: string;
+        nodeAdapterVersion: string;
+        remoteType: string;
+        expose: string;
+        manifestUrl: string;
+        containerEntry: string;
+        source: {
+            module: string;
+        };
+        readinessPath: string;
+        openapiPath: string;
+        deliveryUnit?: import("@modern-js/backend-federation-contracts").DeliveryUnitContractBlock | undefined;
+        versionBoundary: {
+            invariant: string;
+            packageName: string | undefined;
+            version: string | undefined;
+            buildVersion: string | undefined;
+            uiManifestUrl?: string | undefined;
+            deliveryUnit?: {
+                unitId: string;
+                buildMarker: string;
+                sourceRevision: string;
+            } | undefined;
+        };
+    };
+};

package/dist/types/backend-federation-build/config.d.ts

@@ -0,0 +1,102 @@
+import { type DeliveryUnitContractBlock, type UltramodernBuildArtifact } from '@modern-js/backend-federation-contracts';
+export declare const COMPACT_CONFIG_PATH = ".modernjs/ultramodern.json";
+export type CompactApp = {
+    id?: unknown;
+    kind?: unknown;
+    path?: unknown;
+    package?: unknown;
+    port?: unknown;
+    api?: {
+        prefix?: unknown;
+        stem?: unknown;
+    };
+    moduleFederation?: {
+        name?: unknown;
+        manifestUrl?: unknown;
+    };
+    backendFederation?: {
+        name?: unknown;
+        versionBoundary?: {
+            ui?: {
+                manifestUrl?: unknown;
+            };
+        };
+        executionSurfaces?: {
+            node?: {
+                remoteName?: unknown;
+                manifestUrl?: unknown;
+                containerEntry?: unknown;
+                remoteType?: unknown;
+            };
+        };
+    };
+    deliveryUnit?: {
+        unitId?: unknown;
+        buildMarker?: unknown;
+        sourceRevision?: unknown;
+        packageName?: unknown;
+        version?: unknown;
+    };
+    serverExecution?: {
+        node?: {
+            remoteName?: unknown;
+            manifestUrl?: unknown;
+            containerEntry?: unknown;
+            remoteType?: unknown;
+        };
+    };
+};
+export type CompactConfig = {
+    topology?: {
+        apps?: CompactApp[];
+    };
+};
+export type BackendFederationApp = {
+    id: string;
+    directory: string;
+    packageName?: string;
+    version?: string;
+    buildVersion?: string;
+    unitId?: string;
+    sourceRevision?: string;
+    deliveryUnit?: DeliveryUnitContractBlock;
+    port: number;
+    apiPrefix: string;
+    apiStem: string;
+    backendName: string;
+    manifestUrl: string;
+    containerEntry: string;
+    remoteType: string;
+    uiManifestUrl?: string;
+    compactDeliveryUnit?: {
+        unitId?: string;
+        buildMarker?: string;
+        sourceRevision?: string;
+        packageName?: string;
+        version?: string;
+    };
+};
+export type BackendFederationBuildIdentity = {
+    appId?: string;
+    packageName?: string;
+    version?: string;
+    buildVersion?: string;
+    unitId?: string;
+    sourceRevision?: string;
+    artifact?: UltramodernBuildArtifact;
+};
+export declare const normalizeRelativePath: (value: string) => string;
+export declare const buildArtifactPathFor: (appDirectory: string) => string;
+export declare const readBuildIdentity: (appDirectory: string) => Promise<BackendFederationBuildIdentity>;
+export declare const findWorkspaceRoot: (appDirectory: string) => string | undefined;
+export declare const resolveWorkspaceSourceRevision: (workspaceRoot: string) => Promise<string>;
+export declare const createStampedDeliveryUnit: (input: {
+    appId: string;
+    unitId?: string;
+    buildMarker?: string;
+    packageName?: string;
+    version?: string;
+    sourceRevision: string;
+}) => DeliveryUnitContractBlock | undefined;
+export declare const createAppFromCompactMetadata: (workspaceRoot: string, appDirectory: string, compactApp: CompactApp) => BackendFederationApp | undefined;
+export declare const findBackendFederationApp: (workspaceRoot: string, appDirectory: string) => Promise<BackendFederationApp | undefined>;

package/dist/types/backend-federation-build/emit.d.ts

@@ -0,0 +1,21 @@
+export type { BackendFederationBuildIdentity } from './config.js';
+export type BackendFederationArtifactResult = {
+    appId: string;
+    manifestPath: string;
+    containerPath: string;
+    deliveryUnitArtifactPath?: string;
+    remoteName: string;
+    remoteType: string;
+};
+export declare const emitBackendFederationArtifacts: (appDirectory: string, distDirectory: string) => Promise<BackendFederationArtifactResult | undefined>;
+export default _default;
+declare function _default(): {
+    name: string;
+    setup(api: {
+        getAppContext(): {
+            appDirectory: string;
+            distDirectory: string;
+        };
+        onAfterBuild(handler: () => Promise<void>): void;
+    }): void;
+};

package/dist/types/backend-federation-build/index.d.ts

@@ -0,0 +1,2 @@
+export type { BackendFederationArtifactResult } from './emit.js';
+export { default, emitBackendFederationArtifacts } from './emit.js';

package/dist/types/build-config/build-environment.d.ts

@@ -0,0 +1,22 @@
+import type { URL } from 'node:url';
+import type { Rspack } from '@rsbuild/core';
+/**
+ * Reads an environment variable while keeping generated build configs free of
+ * direct process access.
+ */
+export declare function getBuildConfigEnvironment(name: string): string | undefined;
+/**
+ * Runs a Rspack config setup under a leased environment value. The lease is
+ * restored when that compiler reaches any supported terminal hook.
+ */
+export declare function withBuildConfigEnvironment<Config extends {
+    plugins?: Rspack.Plugin[];
+}, SetupArguments extends unknown[]>(name: string, value: string, setup: (config: Config, ...args: SetupArguments) => Config | void | Promise<Config | void>): (config: Config, ...args: SetupArguments) => Promise<Config>;
+export type ResolveEffectTsgoCompilerOptions = {
+    /** Module URL or absolute filename used to resolve the consumer's compiler. */
+    from: string | URL;
+};
+/**
+ * Resolves the Effect TS-Go executable used by Module Federation DTS builds.
+ */
+export declare function resolveEffectTsgoCompiler(options: ResolveEffectTsgoCompilerOptions): string;

package/dist/types/build-config/precompress/plugin.d.ts

@@ -0,0 +1,4 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { PrecompressConfig } from './types.js';
+export type { PrecompressCodecOptions, PrecompressConfig } from './types.js';
+export declare const builderPluginAdapterPrecompress: (precompress: boolean | PrecompressConfig | undefined) => RsbuildPlugin;

package/dist/types/build-config/precompress/types.d.ts

@@ -0,0 +1,19 @@
+import type { CompressionPluginOptions } from '../../precompress/index.js';
+export type PrecompressCodecOptions = boolean | Partial<CompressionPluginOptions>;
+export interface PrecompressConfig {
+    /**
+     * Configure gzip precompression options.
+     * `true` means using default options.
+     * `false` means disabling gzip precompression.
+     * @default true
+     */
+    gzip?: PrecompressCodecOptions;
+    /**
+     * Configure brotli precompression options.
+     * `true` means using default options.
+     * `false` means disabling brotli precompression.
+     * @default true
+     */
+    brotli?: PrecompressCodecOptions;
+}
+export {};