@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.1

package/dist/cjs/module-federation-config/syntax.js

@@ -0,0 +1,151 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    findCreateModuleFederationConfigObject: ()=>findCreateModuleFederationConfigObject,
+    findExportDefaultObject: ()=>findExportDefaultObject,
+    locateCreateModuleFederationConfigObject: ()=>locateCreateModuleFederationConfigObject,
+    parseConfigModule: ()=>parseConfigModule,
+    parseStaticExpression: ()=>parseStaticExpression
+});
+const parser_namespaceObject = require("@babel/parser");
+function unwrapExpression(node) {
+    while('TSAsExpression' === node.type || 'TSSatisfiesExpression' === node.type || 'TSNonNullExpression' === node.type || 'TSTypeAssertion' === node.type || 'ParenthesizedExpression' === node.type)node = node.expression;
+    return node;
+}
+function parseStaticExpression(source) {
+    if (void 0 === source) return;
+    try {
+        return unwrapExpression((0, parser_namespaceObject.parseExpression)(source, {
+            plugins: [
+                "typescript"
+            ]
+        }));
+    } catch  {
+        return;
+    }
+}
+function parseConfigModule(source) {
+    return (0, parser_namespaceObject.parse)(source, {
+        sourceType: 'module',
+        plugins: [
+            "typescript"
+        ]
+    });
+}
+function locateExportedConfig(source, factory) {
+    const module = parseConfigModule(source);
+    const constants = new Map();
+    const bindingStarts = new Map();
+    const resolvedBindings = new Set();
+    const allowedReferences = new Set();
+    const factories = new Set();
+    const namespaces = new Set();
+    const defaults = [];
+    for (const statement of module.program.body){
+        if ('ImportDeclaration' === statement.type && 'type' !== statement.importKind && '@module-federation/modern-js-v3' === statement.source.value) {
+            for (const specifier of statement.specifiers)if ('ImportNamespaceSpecifier' === specifier.type) namespaces.add(specifier.local.name);
+            else if ('ImportSpecifier' === specifier.type && 'type' !== specifier.importKind && ('Identifier' === specifier.imported.type ? specifier.imported.name : specifier.imported.value) === 'createModuleFederationConfig') factories.add(specifier.local.name);
+        }
+        const declaration = 'ExportNamedDeclaration' === statement.type ? statement.declaration : statement;
+        if (declaration?.type === 'VariableDeclaration' && 'const' === declaration.kind) {
+            for (const binding of declaration.declarations)if ('Identifier' === binding.id.type && binding.init) {
+                constants.set(binding.id.name, binding.init);
+                bindingStarts.set(binding.id.name, binding.id.start);
+            }
+        }
+        if ('ExportDefaultDeclaration' === statement.type) defaults.push(statement.declaration);
+        else if ('ExportNamedDeclaration' === statement.type && !statement.source && 'type' !== statement.exportKind) {
+            for (const specifier of statement.specifiers)if ('ExportSpecifier' === specifier.type && 'type' !== specifier.exportKind && ('Identifier' === specifier.exported.type ? specifier.exported.name : specifier.exported.value) === 'default') defaults.push(specifier.local);
+        }
+    }
+    const resolve = (node, seen = new Set())=>{
+        if (!node) return;
+        if ('Identifier' === node.type) {
+            if (seen.has(node.name)) return;
+            seen.add(node.name);
+            resolvedBindings.add(node.name);
+            if (null != node.start) allowedReferences.add(node.start);
+            const bindingStart = bindingStarts.get(node.name);
+            if (null != bindingStart) allowedReferences.add(bindingStart);
+            return resolve(constants.get(node.name), seen);
+        }
+        if ('TSAsExpression' === node.type || 'TSSatisfiesExpression' === node.type || 'TSNonNullExpression' === node.type || 'TSTypeAssertion' === node.type || 'ParenthesizedExpression' === node.type) return resolve(node.expression, seen);
+        return node;
+    };
+    if (1 !== defaults.length) return;
+    let node = resolve(defaults[0]);
+    if (factory) {
+        if (node?.type !== 'CallExpression' || 1 !== node.arguments.length) return;
+        const callee = node.callee;
+        const supported = 'Identifier' === callee.type && factories.has(callee.name) || 'MemberExpression' === callee.type && !callee.computed && 'Identifier' === callee.object.type && namespaces.has(callee.object.name) && 'Identifier' === callee.property.type && 'createModuleFederationConfig' === callee.property.name;
+        if (!supported) return;
+        const argument = node.arguments[0];
+        if (!argument || 'SpreadElement' === argument.type || 'ArgumentPlaceholder' === argument.type) return;
+        node = resolve(argument);
+    }
+    if (node?.type !== 'ObjectExpression' || null == node.start || null == node.end) return;
+    const hasOtherReference = (value)=>{
+        if (!value || 'object' != typeof value) return false;
+        if (Array.isArray(value)) return value.some(hasOtherReference);
+        const entry = value;
+        if ('Identifier' === entry.type && 'string' == typeof entry.name && resolvedBindings.has(entry.name) && ('number' != typeof entry.start || !allowedReferences.has(entry.start))) return true;
+        return Object.entries(entry).some(([key, child])=>'loc' !== key && 'comments' !== key && 'leadingComments' !== key && 'trailingComments' !== key && hasOtherReference(child));
+    };
+    if (hasOtherReference(module.program)) return;
+    return {
+        start: node.start,
+        end: node.end,
+        source: source.slice(node.start, node.end)
+    };
+}
+function locateCreateModuleFederationConfigObject(source) {
+    return locateExportedConfig(source, true);
+}
+function findCreateModuleFederationConfigObject(source) {
+    return locateCreateModuleFederationConfigObject(source)?.source;
+}
+function findExportDefaultObject(source) {
+    return locateExportedConfig(source, false)?.source;
+}
+exports.findCreateModuleFederationConfigObject = __webpack_exports__.findCreateModuleFederationConfigObject;
+exports.findExportDefaultObject = __webpack_exports__.findExportDefaultObject;
+exports.locateCreateModuleFederationConfigObject = __webpack_exports__.locateCreateModuleFederationConfigObject;
+exports.parseConfigModule = __webpack_exports__.parseConfigModule;
+exports.parseStaticExpression = __webpack_exports__.parseStaticExpression;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "findCreateModuleFederationConfigObject",
+    "findExportDefaultObject",
+    "locateCreateModuleFederationConfigObject",
+    "parseConfigModule",
+    "parseStaticExpression"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation-config/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/native-type-checker.js

@@ -38,16 +38,37 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     UltramodernNativeTypeChecker: ()=>UltramodernNativeTypeChecker,
-    configureUltramodernTypeChecker: ()=>configureUltramodernTypeChecker
+    configureUltramodernTypeChecker: ()=>configureUltramodernTypeChecker,
+    missingJsxRuntimeHint: ()=>missingJsxRuntimeHint,
+    resolveNativeTypeCheckerCommand: ()=>resolveNativeTypeCheckerCommand
 });
 const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_crypto_namespaceObject = require("node:crypto");
 const external_node_fs_namespaceObject = require("node:fs");
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_node_util_namespaceObject = require("node:util");
 const builder_namespaceObject = require("@modern-js/builder");
+const external_jsonc_parser_namespaceObject = require("jsonc-parser");
 const execute = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
 const native_type_checker_name = 'UltramodernNativeTypeChecker';
+function resolveNativeTypeCheckerCommand(packageJsonPath) {
+    const manifestFile = (0, external_node_fs_namespaceObject.realpathSync)(packageJsonPath);
+    const directory = external_node_path_default().dirname(manifestFile);
+    const manifest = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(manifestFile, 'utf8'));
+    if ("typescript" !== manifest.name || '7.0.2' !== manifest.version) throw new Error(`${native_type_checker_name} requires typescript@7.0.2; found ${String(manifest.name)}@${String(manifest.version)} at ${manifestFile}.`);
+    const bin = manifest.bin?.tsc;
+    if ('string' != typeof bin || !bin || external_node_path_default().isAbsolute(bin)) throw new Error(`${native_type_checker_name} requires the selected package's public tsc bin.`);
+    const launcher = (0, external_node_fs_namespaceObject.realpathSync)(external_node_path_default().resolve(directory, bin));
+    const relative = external_node_path_default().relative(directory, launcher);
+    if (!relative || external_node_path_default().isAbsolute(relative) || '..' === relative || relative.startsWith(`..${external_node_path_default().sep}`) || !(0, external_node_fs_namespaceObject.statSync)(launcher).isFile()) throw new Error(`${native_type_checker_name} public tsc bin must belong to its selected package.`);
+    return {
+        executable: process.execPath,
+        args: [
+            launcher
+        ]
+    };
+}
 const watchDependencyPath = (file)=>{
     if ('win32' !== process.platform) return file;
     try {
@@ -56,9 +77,87 @@ const watchDependencyPath = (file)=>{
         return file;
     }
 };
+function missingJsxRuntimeHint(diagnostics) {
+    const source = /error TS2875: This JSX tag requires the module path '(.+?)\/jsx-(?:dev-)?runtime'/u.exec(diagnostics)?.[1];
+    if (!source) return '';
+    return `\nHint: JSX compiles against jsxImportSource '${source}', the selected renderer's runtime, but '${source}/jsx-runtime' cannot be resolved from this app. If you changed \`renderer\` in modern.config, install that renderer's packages and port components authored for the previous renderer, or switch \`renderer\` back.\n`;
+}
 class UltramodernNativeTypeChecker {
     async check() {
-        const { configFile, build } = this.options;
+        const configFile = await this.projectConfigFile();
+        try {
+            await this.checkProject(configFile);
+        } finally{
+            this.removeProjection(configFile);
+        }
+    }
+    async projectConfigFile() {
+        const { configFile, configOverwrite } = this.options;
+        if (!configOverwrite) return configFile;
+        const errors = [];
+        const source = (0, external_node_fs_namespaceObject.readFileSync)(configFile, 'utf8');
+        const project = (0, external_jsonc_parser_namespaceObject.parse)(0xfeff === source.charCodeAt(0) ? source.slice(1) : source, errors, {
+            allowTrailingComma: true
+        });
+        if (errors.length) throw new Error(`${native_type_checker_name} requires valid JSONC in ${configFile}: ${errors.map((error)=>`${(0, external_jsonc_parser_namespaceObject.printParseErrorCode)(error.error)} at ${error.offset}`).join(', ')}`);
+        if (!project || 'object' != typeof project || Array.isArray(project)) throw new Error(`${native_type_checker_name} requires a JSONC object in ${configFile}.`);
+        const projectedConfig = {
+            ...project,
+            ...configOverwrite,
+            compilerOptions: {
+                ...project.compilerOptions,
+                ...configOverwrite.compilerOptions
+            }
+        };
+        const projected = external_node_path_default().join(external_node_path_default().dirname(configFile), `.ultramodern-native-checker.${(0, external_node_crypto_namespaceObject.randomUUID)()}.json`);
+        (0, external_node_fs_namespaceObject.writeFileSync)(projected, `${JSON.stringify(projectedConfig, null, 2)}\n`, {
+            flag: 'wx'
+        });
+        try {
+            const resolved = JSON.parse(await this.run([
+                '--showConfig',
+                '--project',
+                projected
+            ]));
+            const options = resolved.compilerOptions ?? {};
+            if ((this.options.build || true === options.incremental || true === options.composite) && !options.tsBuildInfoFile) {
+                const original = configFile.slice(0, configFile.length - external_node_path_default().extname(configFile).length);
+                let buildInfo = original;
+                if ('string' == typeof options.outDir) {
+                    const outDir = external_node_path_default().resolve(external_node_path_default().dirname(configFile), options.outDir);
+                    buildInfo = 'string' == typeof options.rootDir ? external_node_path_default().resolve(outDir, external_node_path_default().relative(external_node_path_default().resolve(external_node_path_default().dirname(configFile), options.rootDir), original)) : external_node_path_default().join(outDir, external_node_path_default().basename(original));
+                }
+                projectedConfig.compilerOptions = {
+                    ...projectedConfig.compilerOptions,
+                    tsBuildInfoFile: `${buildInfo}.tsbuildinfo`
+                };
+                (0, external_node_fs_namespaceObject.writeFileSync)(projected, `${JSON.stringify(projectedConfig, null, 2)}\n`);
+            }
+            return projected;
+        } catch (error) {
+            (0, external_node_fs_namespaceObject.unlinkSync)(projected);
+            throw error;
+        }
+    }
+    removeProjection(configFile) {
+        if (configFile !== this.options.configFile) (0, external_node_fs_namespaceObject.unlinkSync)(configFile);
+    }
+    async checkProject(configFile) {
+        const { 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)=>external_node_path_default().resolve(external_node_path_default().dirname(configFile), reference.path)),
+                '--stopBuildOnErrors',
+                '--pretty',
+                'false'
+            ]);
+        }
         const args = build ? [
             '--build',
             configFile,
@@ -76,7 +175,15 @@ class UltramodernNativeTypeChecker {
     }
     async run(args) {
         try {
-            const result = await execute(this.options.compiler(), args, {
+            const selected = this.options.compiler();
+            const command = 'string' == typeof selected ? {
+                executable: selected,
+                args: []
+            } : selected;
+            const result = await execute(command.executable, [
+                ...command.args,
+                ...args
+            ], {
                 cwd: external_node_path_default().dirname(this.options.configFile),
                 maxBuffer: 16777216
             });
@@ -84,22 +191,22 @@ class UltramodernNativeTypeChecker {
         } 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))}`, {
+            throw new Error(`${native_type_checker_name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}${missingJsxRuntimeHint(diagnostics)}`, {
                 cause
             });
         }
     }
-    async watchInputs() {
+    async watchInputs(configFile) {
         const inputs = new Set();
         const missing = new Set();
         const projects = [
-            this.options.configFile
+            configFile
         ];
         const visited = new Set();
         for (const configFile of projects){
             if (visited.has(configFile)) continue;
             visited.add(configFile);
-            inputs.add(configFile);
+            if (configFile === this.options.configFile || configFile !== projects[0]) inputs.add(configFile);
             if (!(0, external_node_fs_namespaceObject.existsSync)(configFile)) {
                 missing.add(configFile);
                 continue;
@@ -137,10 +244,15 @@ class UltramodernNativeTypeChecker {
                         compilation.fileDependencies.add(watched);
                         if (!(0, external_node_fs_namespaceObject.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();
+                    const configFile = await this.projectConfigFile();
+                    try {
+                        const { inputs, missing } = await this.watchInputs(configFile);
+                        for (const file of inputs)compilation.fileDependencies.add(watchDependencyPath(file));
+                        for (const file of missing)compilation.missingDependencies.add(watchDependencyPath(file));
+                        await this.checkProject(configFile);
+                    } finally{
+                        this.removeProjection(configFile);
+                    }
                 } catch (cause) {
                     compilation.errors.push(new Error(cause instanceof Error ? cause.message : String(cause), {
                         cause
@@ -164,15 +276,20 @@ function configureUltramodernTypeChecker(chain, pluginId, resolveCompiler) {
         {
             build: true === typescript.build,
             compiler: ()=>resolveCompiler(configFile),
-            configFile
+            configFile,
+            configOverwrite: typescript.configOverwrite
         }
     ]);
 }
 exports.UltramodernNativeTypeChecker = __webpack_exports__.UltramodernNativeTypeChecker;
 exports.configureUltramodernTypeChecker = __webpack_exports__.configureUltramodernTypeChecker;
+exports.missingJsxRuntimeHint = __webpack_exports__.missingJsxRuntimeHint;
+exports.resolveNativeTypeCheckerCommand = __webpack_exports__.resolveNativeTypeCheckerCommand;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "UltramodernNativeTypeChecker",
-    "configureUltramodernTypeChecker"
+    "configureUltramodernTypeChecker",
+    "missingJsxRuntimeHint",
+    "resolveNativeTypeCheckerCommand"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/policy-defaults.js

@@ -35,6 +35,7 @@ __webpack_require__.d(__webpack_exports__, {
     RENDERER_EXTENSIONS_PACKAGE: ()=>RENDERER_EXTENSIONS_PACKAGE,
     RENDERER_EXTENSIONS_PLUGIN_NAME: ()=>RENDERER_EXTENSIONS_PLUGIN_NAME,
     SERVER_EXTENSIONS_PLUGIN_NAME: ()=>SERVER_EXTENSIONS_PLUGIN_NAME,
+    ULTRAMODERN_SERVER_EXTENSIONS_PLUGIN_NAME: ()=>ULTRAMODERN_SERVER_EXTENSIONS_PLUGIN_NAME,
     applyPolicyDefaults: ()=>applyPolicyDefaults,
     createPolicyDefaultsPlugin: ()=>createPolicyDefaultsPlugin
 });
@@ -42,50 +43,57 @@ const external_runtime_package_resolution_js_namespaceObject = require("./runtim
 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 ULTRAMODERN_SERVER_EXTENSIONS_PLUGIN_NAME = '@modern-js/ultramodern-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: {}
+const applyPolicyDefaults = (api, options = {}, composition = {})=>{
+    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 runtimePackages = [
+        ...false !== options.rendererExtensions ? [
+            RENDERER_EXTENSIONS_PACKAGE
+        ] : [],
+        ...(composition.runtimePackages ?? []).filter((packageName)=>packageName !== RENDERER_EXTENSIONS_PACKAGE)
+    ];
+    const moduleDirectories = (0, external_runtime_package_resolution_js_namespaceObject.collectRuntimePackageModuleDirectories)(runtimePackages, composition.registrarUrl ?? __rslib_import_meta_url__);
+    if (moduleDirectories.length > 0) api.modifyResolvedConfig((config)=>({
+            ...config,
+            builderPlugins: [
+                ...config.builderPlugins ?? [],
+                (0, external_runtime_package_resolution_js_namespaceObject.createRuntimePackageResolutionPlugin)(moduleDirectories)
+            ]
+        }));
+    if (false !== options.serverExtensions) {
+        const serverPluginName = composition.serverPluginName ?? SERVER_EXTENSIONS_PLUGIN_NAME;
+        api._internalServerPlugins(({ plugins })=>{
+            if (!plugins.some((plugin)=>plugin.name === serverPluginName || plugin.name === SERVER_EXTENSIONS_PLUGIN_NAME || plugin.name === ULTRAMODERN_SERVER_EXTENSIONS_PLUGIN_NAME)) plugins.push({
+                name: serverPluginName
             });
             return {
-                entrypoint,
                 plugins
             };
         });
-        const moduleDirectories = (0, external_runtime_package_resolution_js_namespaceObject.collectRuntimePackageModuleDirectories)([
-            RENDERER_EXTENSIONS_PACKAGE
-        ], __rslib_import_meta_url__);
-        if (moduleDirectories.length > 0) api.modifyResolvedConfig((config)=>({
-                ...config,
-                builderPlugins: [
-                    ...config.builderPlugins ?? [],
-                    (0, external_runtime_package_resolution_js_namespaceObject.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,
+const createPolicyDefaultsPlugin = (options = {}, composition = {})=>({
+        name: composition.pluginName ?? POLICY_DEFAULTS_PLUGIN_NAME,
         setup (api) {
-            applyPolicyDefaults(api, options);
+            applyPolicyDefaults(api, options, composition);
         }
     });
 exports.POLICY_DEFAULTS_PLUGIN_NAME = __webpack_exports__.POLICY_DEFAULTS_PLUGIN_NAME;
 exports.RENDERER_EXTENSIONS_PACKAGE = __webpack_exports__.RENDERER_EXTENSIONS_PACKAGE;
 exports.RENDERER_EXTENSIONS_PLUGIN_NAME = __webpack_exports__.RENDERER_EXTENSIONS_PLUGIN_NAME;
 exports.SERVER_EXTENSIONS_PLUGIN_NAME = __webpack_exports__.SERVER_EXTENSIONS_PLUGIN_NAME;
+exports.ULTRAMODERN_SERVER_EXTENSIONS_PLUGIN_NAME = __webpack_exports__.ULTRAMODERN_SERVER_EXTENSIONS_PLUGIN_NAME;
 exports.applyPolicyDefaults = __webpack_exports__.applyPolicyDefaults;
 exports.createPolicyDefaultsPlugin = __webpack_exports__.createPolicyDefaultsPlugin;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
@@ -93,6 +101,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "RENDERER_EXTENSIONS_PACKAGE",
     "RENDERER_EXTENSIONS_PLUGIN_NAME",
     "SERVER_EXTENSIONS_PLUGIN_NAME",
+    "ULTRAMODERN_SERVER_EXTENSIONS_PLUGIN_NAME",
     "applyPolicyDefaults",
     "createPolicyDefaultsPlugin"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/release-envelope/canonical.js

@@ -31,9 +31,10 @@ __webpack_require__.d(__webpack_exports__, {
     canonicalSerializeMicroVerticalReleaseEnvelope: ()=>canonicalSerializeMicroVerticalReleaseEnvelope,
     canonicalSerializeMicroVerticalReleaseEnvelopePayload: ()=>canonicalSerializeMicroVerticalReleaseEnvelopePayload,
     digestMicroVerticalReleaseEnvelopePayload: ()=>digestMicroVerticalReleaseEnvelopePayload,
-    releaseEnvelopePayload: ()=>releaseEnvelopePayload
+    releaseEnvelopePayload: ()=>external_contract_js_namespaceObject.releaseEnvelopePayload
 });
 const external_node_crypto_namespaceObject = require("node:crypto");
+const external_contract_js_namespaceObject = require("./contract.js");
 const serializeCanonicalValue = (value)=>{
     if (null === value || 'object' != typeof value) {
         if ('number' == typeof value && !Number.isFinite(value)) throw new Error('Canonical release-envelope values must be finite.');
@@ -42,14 +43,6 @@ const serializeCanonicalValue = (value)=>{
     if (Array.isArray(value)) return `[${value.map(serializeCanonicalValue).join(',')}]`;
     return `{${Object.keys(value).sort().map((key)=>`${JSON.stringify(key)}:${serializeCanonicalValue(value[key])}`).join(',')}}`;
 };
-const releaseEnvelopePayload = (envelope)=>({
-        schemaVersion: envelope.schemaVersion,
-        kind: envelope.kind,
-        target: envelope.target,
-        identity: envelope.identity,
-        artifacts: envelope.artifacts,
-        surfaces: envelope.surfaces
-    });
 const canonicalSerializeMicroVerticalReleaseEnvelopePayload = (payload)=>serializeCanonicalValue(payload);
 const canonicalSerializeMicroVerticalReleaseEnvelope = (envelope)=>serializeCanonicalValue(envelope);
 const digestMicroVerticalReleaseEnvelopePayload = (payload)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(canonicalSerializeMicroVerticalReleaseEnvelopePayload(payload)).digest('hex');

package/dist/cjs/release-envelope/contract.js

@@ -0,0 +1,68 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION = 5;
+const MICROVERTICAL_RELEASE_ENVELOPE_KIND = 'ultramodern-target-microvertical-release-envelope';
+const SHELL_RELEASE_ENVELOPE_KIND = 'ultramodern-target-shell-release-envelope';
+const releaseEnvelopePayload = (envelope)=>{
+    const payload = {
+        schemaVersion: envelope.schemaVersion,
+        target: envelope.target,
+        identity: envelope.identity,
+        ...envelope.ui ? {
+            ui: envelope.ui
+        } : {},
+        artifacts: envelope.artifacts
+    };
+    envelope.kind;
+    return {
+        ...payload,
+        kind: envelope.kind,
+        surfaces: envelope.surfaces
+    };
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    MICROVERTICAL_RELEASE_ENVELOPE_KIND: MICROVERTICAL_RELEASE_ENVELOPE_KIND,
+    MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION: MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION,
+    SHELL_RELEASE_ENVELOPE_KIND: SHELL_RELEASE_ENVELOPE_KIND,
+    releaseEnvelopePayload: releaseEnvelopePayload
+});
+exports.MICROVERTICAL_RELEASE_ENVELOPE_KIND = __webpack_exports__.MICROVERTICAL_RELEASE_ENVELOPE_KIND;
+exports.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION = __webpack_exports__.MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION;
+exports.SHELL_RELEASE_ENVELOPE_KIND = __webpack_exports__.SHELL_RELEASE_ENVELOPE_KIND;
+exports.releaseEnvelopePayload = __webpack_exports__.releaseEnvelopePayload;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "MICROVERTICAL_RELEASE_ENVELOPE_KIND",
+    "MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION",
+    "SHELL_RELEASE_ENVELOPE_KIND",
+    "releaseEnvelopePayload"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});