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

package/dist/esm/deploy-output/trace-files.mjs

@@ -0,0 +1,47 @@
+import node_os from "node:os";
+import node_path from "node:path";
+const SYSTEM_ROOTS = 'win32' === process.platform ? [] : [
+    '/dev',
+    '/etc',
+    '/proc',
+    '/run',
+    '/sys',
+    '/var/run'
+];
+const GLOB_SEGMENT = /[*?[{]/;
+const isInside = (parent, child)=>child === parent || child.startsWith(`${parent}${node_path.sep}`);
+const globRoot = (absolutePattern)=>{
+    const { root } = node_path.parse(absolutePattern);
+    const segments = absolutePattern.slice(root.length).split(node_path.sep);
+    const index = segments.findIndex((segment)=>GLOB_SEGMENT.test(segment));
+    return -1 === index ? void 0 : node_path.join(root, ...segments.slice(0, index));
+};
+const createBuildHostIgnore = (base)=>{
+    const wholeDirectories = new Set([
+        node_path.parse(node_path.resolve(base)).root,
+        node_path.resolve(node_os.homedir()),
+        node_path.resolve(node_os.tmpdir())
+    ]);
+    return (relativePath)=>{
+        const absolutePath = node_path.resolve(base, relativePath);
+        if (SYSTEM_ROOTS.some((root)=>isInside(root, absolutePath))) return true;
+        const root = globRoot(absolutePath);
+        return void 0 !== root && wholeDirectories.has(root);
+    };
+};
+const traceDeployFiles = ({ entryFiles, sourceDir, base = '/' })=>{
+    const resolvedBase = node_path.resolve(base);
+    const ignore = createBuildHostIgnore(resolvedBase);
+    try {
+        const options = {
+            base: resolvedBase,
+            processCwd: node_path.resolve(sourceDir || resolvedBase),
+            ignore
+        };
+        const entries = entryFiles.map((file)=>node_path.resolve(file));
+        return import("@vercel/nft").then(({ nodeFileTrace })=>nodeFileTrace(entries, options));
+    } catch (error) {
+        return Promise.reject(error);
+    }
+};
+export { createBuildHostIgnore, traceDeployFiles };

package/dist/esm/module-federation-config/exposes.mjs

@@ -0,0 +1,18 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { inspectModuleFederationConfigSource } from "./inspect.mjs";
+const moduleFederationConfigFile = 'module-federation.config.ts';
+function readModuleFederationConfigInspection(workspaceRoot, appDirectory) {
+    const configPath = node_path.join(workspaceRoot, appDirectory, moduleFederationConfigFile);
+    if (!node_fs.existsSync(configPath)) return;
+    try {
+        const source = node_fs.readFileSync(configPath, 'utf-8');
+        return inspectModuleFederationConfigSource(source, appDirectory, node_path.join(appDirectory, moduleFederationConfigFile));
+    } catch  {
+        return;
+    }
+}
+function readModuleFederationExposePaths(workspaceRoot, appDirectory) {
+    return readModuleFederationConfigInspection(workspaceRoot, appDirectory)?.exposePaths;
+}
+export { readModuleFederationConfigInspection, readModuleFederationExposePaths };

package/dist/esm/module-federation-config/index.mjs

@@ -0,0 +1,4 @@
+export { readModuleFederationConfigInspection, readModuleFederationExposePaths } from "./exposes.mjs";
+export { inspectModuleFederationConfigSource } from "./inspect.mjs";
+export { parseArrayLiteral, parseLiteralString, parseObjectLiteral } from "./object-literal.mjs";
+export { findCreateModuleFederationConfigObject, findExportDefaultObject, locateCreateModuleFederationConfigObject, parseConfigModule, parseStaticExpression } from "./syntax.mjs";

package/dist/esm/module-federation-config/inspect.mjs

@@ -0,0 +1,65 @@
+import { parseArrayLiteral, parseLiteralString, parseObjectLiteral } from "./object-literal.mjs";
+import { findCreateModuleFederationConfigObject, findExportDefaultObject, parseConfigModule } from "./syntax.mjs";
+function extractExposes(configPath, value) {
+    if (void 0 === value) return {
+        exposePaths: {},
+        exposes: []
+    };
+    const object = parseObjectLiteral(value);
+    if (object) {
+        if (object.hasSpread) throw new Error(`Cannot statically extract Module Federation exposes from ${configPath}; use a literal exposes object without spreads.`);
+        const exposePaths = {};
+        for (const [expose, source] of object.properties){
+            const exposePath = parseLiteralString(source);
+            if (void 0 !== exposePath) exposePaths[expose] = exposePath;
+        }
+        return {
+            exposePaths,
+            exposes: Array.from(object.properties.keys()).sort()
+        };
+    }
+    const array = parseArrayLiteral(value);
+    if (array) return {
+        exposePaths: {},
+        exposes: array.sort()
+    };
+    throw new Error(`Cannot statically extract Module Federation exposes from ${configPath}; use a literal exposes object or string array.`);
+}
+function extractDtsSettings(configPath, value, exposes) {
+    if ('false' === value) {
+        if (exposes.length > 0) throw new Error(`Module Federation DTS cannot be disabled for exposed app ${configPath}.`);
+        return {};
+    }
+    if (void 0 === value) return {};
+    const dts = parseObjectLiteral(value);
+    if (!dts || dts.hasSpread) throw new Error(`Cannot statically extract Module Federation DTS settings from ${configPath}; use a literal dts object.`);
+    const generateTypes = parseObjectLiteral(dts.properties.get('generateTypes'));
+    if (generateTypes?.hasSpread) throw new Error(`Cannot statically extract Module Federation generateTypes settings from ${configPath}; use a literal generateTypes object.`);
+    const compilerInstanceSource = generateTypes?.properties.get('compilerInstance');
+    return {
+        compilerInstance: parseLiteralString(compilerInstanceSource) ?? ('tsgoCompilerInstance' === compilerInstanceSource ? 'effect-tsgo' : void 0),
+        tsConfigPath: parseLiteralString(dts.properties.get('tsConfigPath'))
+    };
+}
+function hasHostOnlyNoExposesDeclaration(source) {
+    return (parseConfigModule(source).comments ?? []).some((comment)=>/@?ultramodern-mf\s*:?\s*(?:host-only|no-exposes)\b/iu.test(comment.value));
+}
+function inspectModuleFederationConfigSource(source, appDir, configPath) {
+    const configObject = findCreateModuleFederationConfigObject(source) ?? findExportDefaultObject(source);
+    if (!configObject) throw new Error(`Cannot statically inspect Module Federation config ${configPath}; export or pass a literal config object.`);
+    const properties = parseObjectLiteral(configObject);
+    if (!properties) throw new Error(`Cannot statically inspect Module Federation config ${configPath}; expected a literal config object.`);
+    if (properties.hasSpread) throw new Error(`Cannot statically inspect Module Federation config ${configPath}; top-level config spreads are not supported.`);
+    const { exposePaths, exposes } = extractExposes(configPath, properties.properties.get('exposes'));
+    const hostOnlyNoExposes = hasHostOnlyNoExposesDeclaration(source);
+    if (hostOnlyNoExposes && exposes.length > 0) throw new Error(`Module Federation host-only/no-exposes declaration conflicts with actual exposes in ${configPath}.`);
+    return {
+        appDir,
+        configPath,
+        dts: extractDtsSettings(configPath, properties.properties.get('dts'), exposes),
+        exposePaths,
+        exposes,
+        hostOnlyNoExposes
+    };
+}
+export { inspectModuleFederationConfigSource };

package/dist/esm/module-federation-config/object-literal.mjs

@@ -0,0 +1,43 @@
+import { parseStaticExpression } from "./syntax.mjs";
+function parseLiteralString(source) {
+    const node = parseStaticExpression(source);
+    if (node?.type === 'StringLiteral') return node.value;
+    if (node?.type === 'TemplateLiteral' && 0 === node.expressions.length) return node.quasis[0]?.value.cooked ?? void 0;
+}
+function parseObjectLiteral(source) {
+    const node = parseStaticExpression(source);
+    if (void 0 === source || node?.type !== 'ObjectExpression') return;
+    const properties = new Map();
+    let hasSpread = false;
+    for (const property of node.properties){
+        if ('ObjectProperty' !== property.type || property.computed || property.shorthand) {
+            hasSpread = true;
+            continue;
+        }
+        const key = 'Identifier' === property.key.type ? property.key.name : 'StringLiteral' === property.key.type ? property.key.value : void 0;
+        const value = parseStaticExpression(source.slice(property.value.start ?? 0, property.value.end ?? 0));
+        if (void 0 === key || properties.has(key) || !value || null == value.start || null == value.end) {
+            hasSpread = true;
+            continue;
+        }
+        const rawValue = source.slice(property.value.start ?? 0, property.value.end ?? 0);
+        properties.set(key, rawValue.slice(value.start, value.end));
+    }
+    return {
+        hasSpread,
+        properties
+    };
+}
+function parseArrayLiteral(source) {
+    const node = parseStaticExpression(source);
+    if (void 0 === source || node?.type !== 'ArrayExpression') return;
+    const values = [];
+    for (const element of node.elements){
+        if (!element || 'SpreadElement' === element.type) return;
+        const value = parseLiteralString(source.slice(element.start ?? 0, element.end ?? 0));
+        if (void 0 === value) return;
+        values.push(value);
+    }
+    return values;
+}
+export { parseArrayLiteral, parseLiteralString, parseObjectLiteral };

package/dist/esm/module-federation-config/syntax.mjs

@@ -0,0 +1,101 @@
+import { parse, parseExpression } from "@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(parseExpression(source, {
+            plugins: [
+                "typescript"
+            ]
+        }));
+    } catch  {
+        return;
+    }
+}
+function parseConfigModule(source) {
+    return 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;
+}
+export { findCreateModuleFederationConfigObject, findExportDefaultObject, locateCreateModuleFederationConfigObject, parseConfigModule, parseStaticExpression };

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

@@ -1,10 +1,29 @@
 import { execFile } from "node:child_process";
-import { existsSync, realpathSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import node_path from "node:path";
 import { promisify } from "node:util";
 import { refreshTsgoCheckerConfig } from "@modern-js/builder";
+import { parse, printParseErrorCode } from "jsonc-parser";
 const execute = promisify(execFile);
 const native_type_checker_name = 'UltramodernNativeTypeChecker';
+function resolveNativeTypeCheckerCommand(packageJsonPath) {
+    const manifestFile = realpathSync(packageJsonPath);
+    const directory = node_path.dirname(manifestFile);
+    const manifest = JSON.parse(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 || node_path.isAbsolute(bin)) throw new Error(`${native_type_checker_name} requires the selected package's public tsc bin.`);
+    const launcher = realpathSync(node_path.resolve(directory, bin));
+    const relative = node_path.relative(directory, launcher);
+    if (!relative || node_path.isAbsolute(relative) || '..' === relative || relative.startsWith(`..${node_path.sep}`) || !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 {
@@ -13,9 +32,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 = readFileSync(configFile, 'utf8');
+        const project = 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)=>`${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 = node_path.join(node_path.dirname(configFile), `.ultramodern-native-checker.${randomUUID()}.json`);
+        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 - node_path.extname(configFile).length);
+                let buildInfo = original;
+                if ('string' == typeof options.outDir) {
+                    const outDir = node_path.resolve(node_path.dirname(configFile), options.outDir);
+                    buildInfo = 'string' == typeof options.rootDir ? node_path.resolve(outDir, node_path.relative(node_path.resolve(node_path.dirname(configFile), options.rootDir), original)) : node_path.join(outDir, node_path.basename(original));
+                }
+                projectedConfig.compilerOptions = {
+                    ...projectedConfig.compilerOptions,
+                    tsBuildInfoFile: `${buildInfo}.tsbuildinfo`
+                };
+                writeFileSync(projected, `${JSON.stringify(projectedConfig, null, 2)}\n`);
+            }
+            return projected;
+        } catch (error) {
+            unlinkSync(projected);
+            throw error;
+        }
+    }
+    removeProjection(configFile) {
+        if (configFile !== this.options.configFile) 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)=>node_path.resolve(node_path.dirname(configFile), reference.path)),
+                '--stopBuildOnErrors',
+                '--pretty',
+                'false'
+            ]);
+        }
         const args = build ? [
             '--build',
             configFile,
@@ -33,7 +130,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: node_path.dirname(this.options.configFile),
                 maxBuffer: 16777216
             });
@@ -41,22 +146,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 (!existsSync(configFile)) {
                 missing.add(configFile);
                 continue;
@@ -94,10 +199,15 @@ class UltramodernNativeTypeChecker {
                         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();
+                    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
@@ -121,8 +231,9 @@ function configureUltramodernTypeChecker(chain, pluginId, resolveCompiler) {
         {
             build: true === typescript.build,
             compiler: ()=>resolveCompiler(configFile),
-            configFile
+            configFile,
+            configOverwrite: typescript.configOverwrite
         }
     ]);
 }
-export { UltramodernNativeTypeChecker, configureUltramodernTypeChecker };
+export { UltramodernNativeTypeChecker, configureUltramodernTypeChecker, missingJsxRuntimeHint, resolveNativeTypeCheckerCommand };

package/dist/esm/policy-defaults.mjs

@@ -2,44 +2,50 @@ import { collectRuntimePackageModuleDirectories, createRuntimePackageResolutionP
 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 = collectRuntimePackageModuleDirectories(runtimePackages, composition.registrarUrl ?? import.meta.url);
+    if (moduleDirectories.length > 0) api.modifyResolvedConfig((config)=>({
+            ...config,
+            builderPlugins: [
+                ...config.builderPlugins ?? [],
+                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 = 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,
+const createPolicyDefaultsPlugin = (options = {}, composition = {})=>({
+        name: composition.pluginName ?? POLICY_DEFAULTS_PLUGIN_NAME,
         setup (api) {
-            applyPolicyDefaults(api, options);
+            applyPolicyDefaults(api, options, composition);
         }
     });
-export { POLICY_DEFAULTS_PLUGIN_NAME, RENDERER_EXTENSIONS_PACKAGE, RENDERER_EXTENSIONS_PLUGIN_NAME, SERVER_EXTENSIONS_PLUGIN_NAME, applyPolicyDefaults, createPolicyDefaultsPlugin };
+export { POLICY_DEFAULTS_PLUGIN_NAME, RENDERER_EXTENSIONS_PACKAGE, RENDERER_EXTENSIONS_PLUGIN_NAME, SERVER_EXTENSIONS_PLUGIN_NAME, ULTRAMODERN_SERVER_EXTENSIONS_PLUGIN_NAME, applyPolicyDefaults, createPolicyDefaultsPlugin };

package/dist/esm/release-envelope/canonical.mjs

@@ -7,15 +7,8 @@ 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)=>createHash('sha256').update(canonicalSerializeMicroVerticalReleaseEnvelopePayload(payload)).digest('hex');
-export { canonicalSerializeMicroVerticalReleaseEnvelope, canonicalSerializeMicroVerticalReleaseEnvelopePayload, digestMicroVerticalReleaseEnvelopePayload, releaseEnvelopePayload };
+export { releaseEnvelopePayload } from "./contract.mjs";
+export { canonicalSerializeMicroVerticalReleaseEnvelope, canonicalSerializeMicroVerticalReleaseEnvelopePayload, digestMicroVerticalReleaseEnvelopePayload };

package/dist/esm/release-envelope/contract.mjs

@@ -0,0 +1,21 @@
+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
+    };
+};
+export { MICROVERTICAL_RELEASE_ENVELOPE_KIND, MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION, SHELL_RELEASE_ENVELOPE_KIND, releaseEnvelopePayload };