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

package/dist/esm-node/deploy-output/npmAliases.mjs

@@ -0,0 +1,175 @@
+import "node:module";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+const dependencyKeys = [
+    'dependencies',
+    'optionalDependencies'
+];
+const exactVersionPattern = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
+async function readPackageJson(filePath) {
+    return JSON.parse(await promises.readFile(filePath, 'utf8'));
+}
+function parseNpmAlias(aliasName, specifier) {
+    if (!specifier.startsWith('npm:')) return;
+    const target = specifier.slice(4);
+    const versionSeparator = target.lastIndexOf('@');
+    if (versionSeparator <= 0 || versionSeparator === target.length - 1) throw new Error(`Invalid npm alias specifier for ${aliasName}: ${specifier}`);
+    return {
+        aliasName,
+        targetName: target.slice(0, versionSeparator),
+        targetVersion: target.slice(versionSeparator + 1)
+    };
+}
+function aliasesFromPackageJson(packageJson) {
+    const aliases = [];
+    for (const dependencyKey of dependencyKeys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
+        const alias = parseNpmAlias(aliasName, specifier);
+        if (alias) aliases.push(alias);
+    }
+    return aliases;
+}
+async function collectPackageRecords(nodeModulesDirectory) {
+    const records = [];
+    const visitedNodeModules = new Set();
+    const visitPackage = async (directory)=>{
+        const packageJsonPath = node_path.join(directory, 'package.json');
+        try {
+            const packageJson = await readPackageJson(packageJsonPath);
+            if (packageJson.name && packageJson.version) records.push({
+                directory,
+                packageJson
+            });
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        await visitNodeModules(node_path.join(directory, 'node_modules'));
+    };
+    const visitScope = async (scopeDirectory)=>{
+        const entries = await promises.readdir(scopeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) await visitPackage(node_path.join(scopeDirectory, entry.name));
+    };
+    const visitNdepeStore = async (storeDirectory)=>{
+        const entries = await promises.readdir(storeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) {
+            const entryPath = node_path.join(storeDirectory, entry.name);
+            if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitNodeModules(node_path.join(entryPath, 'node_modules'));
+        }
+    };
+    const visitNodeModules = async (directory)=>{
+        const resolvedDirectory = node_path.resolve(directory);
+        if (visitedNodeModules.has(resolvedDirectory)) return;
+        visitedNodeModules.add(resolvedDirectory);
+        let entries;
+        try {
+            entries = await promises.readdir(directory, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if ('ENOENT' === error.code) return;
+            throw error;
+        }
+        for (const entry of entries){
+            if (!entry.isDirectory()) continue;
+            const entryPath = node_path.join(directory, entry.name);
+            if ('.ndepe' === entry.name) await visitNdepeStore(entryPath);
+            else if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitPackage(entryPath);
+        }
+    };
+    await visitNodeModules(nodeModulesDirectory);
+    return records;
+}
+async function resolveAliasTarget(ownerDirectory, alias, outputDirectory) {
+    let directory = ownerDirectory;
+    const outputRoot = node_path.resolve(outputDirectory);
+    const resolvedOutputRoot = await promises.realpath(outputRoot);
+    while(directory === outputRoot || directory.startsWith(`${outputRoot}${node_path.sep}`)){
+        const candidate = node_path.join(directory, 'node_modules', alias.targetName);
+        try {
+            const resolvedCandidate = await promises.realpath(candidate);
+            if (resolvedCandidate !== resolvedOutputRoot && !resolvedCandidate.startsWith(`${resolvedOutputRoot}${node_path.sep}`)) throw new Error(`Cannot preserve npm alias ${alias.aliasName}: emitted target ${candidate} resolves outside deployment output to ${resolvedCandidate}`);
+            const packageJson = await readPackageJson(node_path.join(candidate, 'package.json'));
+            if (packageJson.name !== alias.targetName || !packageJson.version) throw new Error(`npm alias ${alias.aliasName} resolved ${candidate} to unexpected package ${String(packageJson.name)}`);
+            if (exactVersionPattern.test(alias.targetVersion) && packageJson.version !== alias.targetVersion) return;
+            return {
+                directory: candidate,
+                packageJson
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        if (directory === outputRoot) break;
+        directory = node_path.dirname(directory);
+    }
+}
+async function ensureAliasLink(ownerDirectory, alias, target) {
+    const aliasPath = node_path.join(ownerDirectory, 'node_modules', alias.aliasName);
+    await promises.mkdir(node_path.dirname(aliasPath), {
+        recursive: true
+    });
+    try {
+        const [existing, expected] = await Promise.all([
+            promises.realpath(aliasPath),
+            promises.realpath(target.directory)
+        ]);
+        if (existing === expected) return;
+        throw new Error(`Cannot preserve npm alias ${alias.aliasName}: ${aliasPath} already resolves to ${existing}, expected ${expected}`);
+    } catch (error) {
+        if ('ENOENT' !== error.code) throw error;
+    }
+    const linkTarget = node_path.relative(node_path.dirname(aliasPath), target.directory);
+    await promises.symlink(linkTarget, aliasPath, 'dir');
+}
+function aliasSpecifier(alias) {
+    return `npm:${alias.targetName}@${alias.targetVersion}`;
+}
+async function readPackageIdentity(entryPath) {
+    let directory = node_path.dirname(entryPath);
+    const root = node_path.parse(directory).root;
+    while(directory !== root){
+        try {
+            const packageJson = await readPackageJson(node_path.join(directory, 'package.json'));
+            if (packageJson.name && packageJson.version) return {
+                name: packageJson.name,
+                version: packageJson.version
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        directory = node_path.dirname(directory);
+    }
+    throw new Error(`Cannot find owning package for deployment entry ${entryPath}`);
+}
+async function preserveNpmAliases({ appDirectory, outputDirectory, implicitAliases = [] }) {
+    const records = await collectPackageRecords(node_path.join(outputDirectory, 'node_modules'));
+    const appPackageJson = await readPackageJson(node_path.join(appDirectory, 'package.json'));
+    const rootAliases = [
+        ...aliasesFromPackageJson(appPackageJson),
+        ...implicitAliases
+    ].filter((alias)=>alias.aliasName !== alias.targetName);
+    const emittedRootAliases = [];
+    for (const alias of rootAliases){
+        const target = await resolveAliasTarget(outputDirectory, alias, outputDirectory);
+        if (!target) {
+            if (implicitAliases.includes(alias)) throw new Error(`Cannot preserve implicit npm alias ${alias.aliasName}: emitted target ${alias.targetName}@${alias.targetVersion} is missing`);
+            continue;
+        }
+        await ensureAliasLink(outputDirectory, alias, target);
+        emittedRootAliases.push(alias);
+    }
+    for (const record of records)for (const alias of aliasesFromPackageJson(record.packageJson).filter((candidate)=>candidate.aliasName !== candidate.targetName)){
+        const target = await resolveAliasTarget(record.directory, alias, outputDirectory);
+        if (target) await ensureAliasLink(record.directory, alias, target);
+    }
+    const outputPackageJsonPath = node_path.join(outputDirectory, 'package.json');
+    const outputPackageJson = await readPackageJson(outputPackageJsonPath);
+    outputPackageJson.dependencies ??= {};
+    for (const alias of emittedRootAliases)outputPackageJson.dependencies[alias.aliasName] = aliasSpecifier(alias);
+    await promises.writeFile(outputPackageJsonPath, `${JSON.stringify(outputPackageJson, null, 2)}\n`);
+}
+export { preserveNpmAliases, readPackageIdentity };

package/dist/esm-node/deploy-output/plugin.mjs

@@ -0,0 +1,31 @@
+import "node:module";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { preserveNpmAliases, readPackageIdentity } from "./npmAliases.mjs";
+import { resolveDeployTarget as external_target_mjs_resolveDeployTarget } from "./target.mjs";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+var __rspack_import_meta_filename__ = __rspack_fileURLToPath(import.meta.url);
+const createDeployOutputAliasesPlugin = ({ resolveDeployTarget = external_target_mjs_resolveDeployTarget } = {})=>({
+        name: '@modern-js/deploy-output-aliases',
+        setup (api) {
+            api.onAfterDeploy(async ()=>{
+                const { appDirectory, metaName } = api.getAppContext();
+                const config = api.getNormalizedConfig();
+                if ('modern-js' !== metaName && !config.deploy?.target && !process.env.MODERNJS_DEPLOY || 'node' !== resolveDeployTarget(config)) return;
+                const entry = createRequire(__rspack_import_meta_filename__).resolve('@modern-js/prod-server');
+                const identity = await readPackageIdentity(entry);
+                await preserveNpmAliases({
+                    appDirectory,
+                    outputDirectory: node_path.join(appDirectory, '.output'),
+                    implicitAliases: [
+                        {
+                            aliasName: '@modern-js/prod-server',
+                            targetName: identity.name,
+                            targetVersion: identity.version
+                        }
+                    ]
+                });
+            });
+        }
+    });
+export { createDeployOutputAliasesPlugin };

package/dist/esm-node/deploy-output/target.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+import { provider } from "std-env";
+const providerDeployTargets = {
+    vercel: 'vercel',
+    netlify: 'netlify',
+    cloudflare: 'cloudflare',
+    cloudflare_pages: 'cloudflare',
+    cloudflare_workers: 'cloudflare'
+};
+const resolveDeployTarget = (config, envDeployTarget = process.env.MODERNJS_DEPLOY, detectedProvider = provider)=>config.deploy?.target || envDeployTarget || (detectedProvider ? providerDeployTargets[detectedProvider] : void 0) || 'node';
+export { resolveDeployTarget };

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

@@ -1,9 +1,11 @@
 import "node:module";
 import { execFile } from "node:child_process";
+import { realpathSync } from "node:fs";
 import node_path from "node:path";
 import { promisify } from "node:util";
 const execute = promisify(execFile);
 const native_type_checker_name = 'UltramodernNativeTypeChecker';
+const watchDependencyPath = (file)=>'win32' === process.platform ? realpathSync.native(file) : file;
 class UltramodernNativeTypeChecker {
     async check() {
         const { configFile, build } = this.options;
@@ -31,7 +33,8 @@ class UltramodernNativeTypeChecker {
             return result.stdout;
         } catch (cause) {
             const output = cause;
-            throw new Error(`${native_type_checker_name} failed:\n${output.stdout ?? ''}${output.stderr ?? ''}`, {
+            const diagnostics = `${output.stdout ?? ''}${output.stderr ?? ''}`;
+            throw new Error(`${native_type_checker_name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}`, {
                 cause
             });
         }
@@ -62,10 +65,10 @@ class UltramodernNativeTypeChecker {
     }
     apply(compiler) {
         compiler.hooks.thisCompilation.tap(native_type_checker_name, (compilation)=>{
-            compilation.fileDependencies.add(this.options.configFile);
             compilation.hooks.processAssets.tapPromise(native_type_checker_name, async ()=>{
                 try {
-                    for (const file of (await this.watchInputs()))compilation.fileDependencies.add(file);
+                    compilation.fileDependencies.add(watchDependencyPath(this.options.configFile));
+                    for (const file of (await this.watchInputs()))compilation.fileDependencies.add(watchDependencyPath(file));
                     await this.check();
                 } catch (cause) {
                     compilation.errors.push(new Error(cause instanceof Error ? cause.message : String(cause), {

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';

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

@@ -11,7 +11,8 @@ 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'

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 {};

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

@@ -0,0 +1,2 @@
+export type { ResolveEffectTsgoCompilerOptions } from './build-environment.js';
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment, } from './build-environment.js';

package/dist/types/cloudflare/constants.d.ts

@@ -16,7 +16,7 @@ export declare const SERVER_OUTPUT_DIRECTORY = "server";
 export declare const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES: readonly ['api', 'shared'];
 export declare const BFF_EFFECT_WORKER_ENTRY = "worker/__modern_bff_effect.js";
 export declare const BFF_EFFECT_WORKER_DISPATCHER_EXPORT = "__modern_create_effect_bff_dispatcher";
-export declare const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = "Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.";
+export declare const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = "Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/bff-effect/effect-edge instead of lambda/Hono server helpers.";
 export declare const DEFAULT_COMPATIBILITY_DATE = "2026-06-02";
 export declare const COMPATIBILITY_DATE_PATTERN: RegExp;
 export declare const REQUIRED_COMPATIBILITY_FLAGS: readonly ["nodejs_compat", "global_fetch_strictly_public"];

package/dist/types/cloudflare/delivery-unit.d.ts

@@ -1,4 +1,4 @@
-import { type DeliveryUnitIdentity } from '@modern-js/utils/universal';
+import { type DeliveryUnitIdentity } from '@modern-js/backend-federation-contracts';
 export type DeliveryUnitStamp = DeliveryUnitIdentity & {
     surfaces: {
         ui?: DeliveryUnitIdentity & {
@@ -17,7 +17,7 @@ export type DeliveryUnitStamp = DeliveryUnitIdentity & {
 export declare const resolveTopologyDeliveryUnit: (appDirectory: string) => Promise<DeliveryUnitStamp | undefined>;
 /**
  * Resolve the delivery-unit identity actually bundled into the worker by
- * parsing the generated `shared/ultramodern-build.ts` module. This is the
+ * reading the generated `shared/ultramodern-build.json` artifact. This is the
  * worker snapshot / declared surface source that gets stamped into the manifest.
  */
 export declare const resolveWorkerDeliveryUnitStamp: (appDirectory: string) => Promise<DeliveryUnitStamp | undefined>;

package/dist/types/cloudflare/worker-manifest.d.ts

@@ -108,8 +108,8 @@ export declare const createWorkerManifest: (outputDirectory: string, modernConfi
         prefix: string;
         worker: string;
         effect: {
-            openapi?: import("@modern-js/server-core").BffEffectOpenApiUserConfig | undefined;
-            dataPlatform?: import("@modern-js/server-core").BffEffectDataPlatformUserConfig | undefined;
+            openapi?: import("@modern-js/runtime-extensions/server-config").BffEffectOpenApiUserConfig | undefined;
+            dataPlatform?: import("@modern-js/runtime-extensions/server-config").BffEffectDataPlatformUserConfig | undefined;
             crossProjectPolicy: {
                 allowedNamespaces?: string[];
                 verifyProducerIdentity?: (headers: Record<string, unknown>) => string | undefined;

package/dist/types/cloudflare-output-verifier/identity.d.ts

@@ -1,4 +1,4 @@
-import { type DeliveryUnitIdentity } from '@modern-js/utils/universal';
+import { type DeliveryUnitIdentity } from '@modern-js/backend-federation-contracts';
 import type { CloudflareOutputVerifierIssue, JsonObject } from './issues.js';
 export type CloudflareDeliveryUnitIdentity = DeliveryUnitIdentity & {
     surfaces?: Partial<Record<'api' | 'ui', DeliveryUnitIdentity & {

package/dist/types/config.d.ts

@@ -1,3 +1,5 @@
+export type { ResolveEffectTsgoCompilerOptions } from './build-config/public.js';
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment, } from './build-config/public.js';
 export type DeployTarget = 'node' | 'vercel' | 'netlify' | 'ghPages' | 'cloudflare';
 export type CloudflareWorkerSecurityCspMode = 'enforce' | 'report-only' | 'off';
 export type JsonValue = string | number | boolean | null | JsonValue[] | {

package/dist/types/deploy-output/npmAliases.d.ts

@@ -0,0 +1,14 @@
+export type NpmAlias = {
+    aliasName: string;
+    targetName: string;
+    targetVersion: string;
+};
+export declare function readPackageIdentity(entryPath: string): Promise<{
+    name: string;
+    version: string;
+}>;
+export declare function preserveNpmAliases({ appDirectory, outputDirectory, implicitAliases, }: {
+    appDirectory: string;
+    outputDirectory: string;
+    implicitAliases?: NpmAlias[];
+}): Promise<void>;

package/dist/types/deploy-output/plugin.d.ts

@@ -0,0 +1,15 @@
+import { type DeployOutputConfig } from './target.js';
+export interface DeployOutputPluginApi {
+    getAppContext(): {
+        appDirectory: string;
+        metaName: string;
+    };
+    getNormalizedConfig(): DeployOutputConfig;
+    onAfterDeploy(handler: () => Promise<void>): void;
+}
+export declare const createDeployOutputAliasesPlugin: ({ resolveDeployTarget, }?: {
+    resolveDeployTarget?: (config: DeployOutputConfig) => string;
+}) => {
+    name: string;
+    setup(api: DeployOutputPluginApi): void;
+};

package/dist/types/deploy-output/target.d.ts

@@ -0,0 +1,6 @@
+export interface DeployOutputConfig {
+    deploy?: {
+        target?: string;
+    };
+}
+export declare const resolveDeployTarget: (config: DeployOutputConfig, envDeployTarget?: string | undefined, detectedProvider?: import("std-env").ProviderName) => string;

package/dist/types/precompress/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.