@bleedingdev/modern-js-ultramodern-create 3.8.3-ultramodern.2

package/dist/esm-node/ultramodern-workspace/descriptors.js

@@ -0,0 +1,192 @@
+import "node:module";
+import { packageName, toCamelCase, toEnvSegment, toKebabCase, toPascalCase } from "./naming.js";
+const ULTRAMODERN_CONFIG_PATH = '.modernjs/ultramodern.json';
+function distributedSsrExposes(app) {
+    return Object.keys(app.exposes ?? {}).filter((expose)=>'./Route' !== expose).toSorted();
+}
+function distributedSsrFragmentSlug(expose) {
+    const slug = toKebabCase(expose.replace(/^\.\//u, ''));
+    if (!slug) throw new Error(`Invalid distributed SSR expose ${expose}.`);
+    return slug;
+}
+function distributedSsrFragmentRoute(expose) {
+    return `/{locale}/_mf/fragment/${distributedSsrFragmentSlug(expose)}`;
+}
+const shellApp = {
+    id: 'shell-super-app',
+    directory: 'apps/shell-super-app',
+    packageSuffix: 'shell-super-app',
+    displayName: 'Shell Super App',
+    kind: 'shell',
+    portEnv: 'SHELL_SUPER_APP_PORT',
+    port: 3020,
+    mfName: 'shellSuperApp',
+    verticalRefs: [],
+    ownership: {
+        team: 'super-app-platform',
+        slack: '#super-app-platform',
+        pagerDuty: 'pd-super-app-platform',
+        runbookRef: 'runbooks/wave2/shell-super-app.md',
+        adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#shell-super-app',
+        blastRadius: {
+            tier: 'tier-0-shell',
+            references: [
+                'docs/super-app-rfc-adr/wave2/blast-radius.md#shell',
+                'docs/super-app-rfc-adr/wave2/rollback.md#shell-lkg'
+            ]
+        }
+    }
+};
+function createShellHost(remotes = [], verticalRefs = remotes.filter(appEmitsBrowserUi).map((remote)=>remote.id)) {
+    return {
+        ...shellApp,
+        verticalRefs
+    };
+}
+const sharedPackages = [
+    {
+        id: 'shared-contracts',
+        directory: 'packages/shared-contracts',
+        description: 'Generated route, ownership, and topology contracts.'
+    },
+    {
+        id: 'shared-design-tokens',
+        directory: 'packages/shared-design-tokens',
+        description: 'Generated design tokens consumed by shell and verticals.'
+    }
+];
+function createNeutralOwnership(id, tier = 'tier-2-vertical') {
+    return {
+        team: 'super-app-platform',
+        slack: '#super-app-platform',
+        pagerDuty: 'pd-super-app-platform',
+        runbookRef: `runbooks/verticals/${id}.md`,
+        adrRef: `docs/super-app-rfc-adr/verticals.md#${id}`,
+        blastRadius: {
+            tier,
+            references: [
+                `docs/super-app-rfc-adr/blast-radius.md#${id}`
+            ]
+        }
+    };
+}
+function createVerticalDescriptor(name, port, options = {}) {
+    const horizontalRemote = options.horizontalRemote ?? false;
+    const preset = horizontalRemote ? 'ui-only' : options.preset ?? 'full-stack';
+    const apiProtocol = options.apiProtocol ?? 'rest';
+    const emitsUi = 'api-only' !== preset;
+    const emitsApi = 'ui-only' !== preset;
+    const domain = toKebabCase(name);
+    const id = domain;
+    const displayPrefix = toPascalCase(domain).replace(/([a-z])([A-Z])/g, '$1 $2');
+    return {
+        id,
+        directory: `verticals/${domain}`,
+        packageSuffix: domain,
+        displayName: `${displayPrefix} Vertical`,
+        kind: 'vertical',
+        domain,
+        portEnv: `VERTICAL_${toEnvSegment(domain)}_PORT`,
+        port,
+        mfName: `vertical${toPascalCase(domain)}`,
+        ...emitsUi ? {
+            exposes: {
+                './Route': './src/federation-entry.tsx',
+                './Widget': `./src/components/${domain}-widget.tsx`
+            }
+        } : {},
+        ...emitsApi ? {
+            api: {
+                stem: domain,
+                prefix: `/${domain}-api`,
+                consumedBy: [
+                    shellApp.id,
+                    id
+                ],
+                ...'rest' !== apiProtocol ? {
+                    protocol: apiProtocol
+                } : {}
+            }
+        } : {},
+        ...'full-stack' !== preset ? {
+            surfaceProfile: preset
+        } : {},
+        ...horizontalRemote ? {
+            deliveryUnitKind: 'horizontal-remote'
+        } : {},
+        ownership: createNeutralOwnership(id)
+    };
+}
+function appHasApi(app) {
+    return void 0 !== app.api;
+}
+function appEmitsBrowserUi(app) {
+    return 'api-only' !== app.surfaceProfile;
+}
+function resolveApiProtocol(app) {
+    return app.api?.protocol ?? 'rest';
+}
+function resolveApiPrefix(target) {
+    return target.api?.prefix ?? `/${toKebabCase(target.id)}-api`;
+}
+function resolveApiStem(target) {
+    return target.api?.stem ?? toKebabCase(target.id).replace(/-api$/, '');
+}
+function verticalApiApps(remotes = []) {
+    return remotes.filter(appHasApi);
+}
+function remoteDependencyAlias(remote) {
+    return toCamelCase(remote.domain ?? remote.id.replace(/^remote-/, ''));
+}
+function zephyrRemoteDependency(scope, remote) {
+    return `${packageName(scope, remote.packageSuffix)}@workspace:*`;
+}
+function resolveRemoteRefs(app, remotes = []) {
+    const verticalRefs = app.verticalRefs ?? [];
+    const remotesById = new Map(remotes.map((remote)=>[
+            remote.id,
+            remote
+        ]));
+    return verticalRefs.map((remoteRef)=>{
+        const remote = remotesById.get(remoteRef);
+        if (void 0 === remote) {
+            const availableRemotes = remotes.map((remote)=>remote.id).join(', ');
+            throw new Error(`Unknown remote vertical reference ${remoteRef} for ${app.id}. Available remotes: ${availableRemotes || 'none'}.`);
+        }
+        return remote;
+    });
+}
+function createRemoteManifestEnv(remote) {
+    return `VERTICAL_${toEnvSegment(remote.domain ?? remote.id)}_MF_MANIFEST`;
+}
+function createBackendFederationManifestEnv(remote) {
+    return `VERTICAL_${toEnvSegment(remote.domain ?? remote.id)}_BACKEND_MF_MANIFEST`;
+}
+function createBackendFederationName(app) {
+    return `${app.mfName}Backend`;
+}
+function createBackendFederationManifestUrl(app) {
+    return `http://localhost:${app.port}/backend-mf-manifest.json`;
+}
+function createBackendFederationContainerEntry(app) {
+    return `http://localhost:${app.port}/backendRemoteEntry.cjs`;
+}
+function createModuleFederationRemoteContracts(app, remotes = []) {
+    return resolveRemoteRefs(app, remotes).map((remote)=>({
+            id: remote.id,
+            alias: remoteDependencyAlias(remote),
+            name: remote.mfName,
+            manifestEnv: createRemoteManifestEnv(remote),
+            manifestUrl: `http://localhost:${remote.port}/mf-manifest.json`
+        }));
+}
+function createCloudflareWorkerName(scope, app) {
+    return toKebabCase(`${scope}-${app.packageSuffix}`).slice(0, 63);
+}
+function createCloudflarePublicUrlEnv(app) {
+    return `ULTRAMODERN_PUBLIC_URL_${toEnvSegment(app.id)}`;
+}
+function appI18nNamespace(app) {
+    return 'shell' === app.kind ? 'shell' : app.domain ?? app.id;
+}
+export { ULTRAMODERN_CONFIG_PATH, appEmitsBrowserUi, appHasApi, appI18nNamespace, createBackendFederationContainerEntry, createBackendFederationManifestEnv, createBackendFederationManifestUrl, createBackendFederationName, createCloudflarePublicUrlEnv, createCloudflareWorkerName, createModuleFederationRemoteContracts, createNeutralOwnership, createRemoteManifestEnv, createShellHost, createVerticalDescriptor, distributedSsrExposes, distributedSsrFragmentRoute, distributedSsrFragmentSlug, remoteDependencyAlias, resolveApiPrefix, resolveApiProtocol, resolveApiStem, resolveRemoteRefs, sharedPackages, shellApp, verticalApiApps, zephyrRemoteDependency };

package/dist/esm-node/ultramodern-workspace/effect-diagnostics.js

@@ -0,0 +1,77 @@
+import "node:module";
+const effectDiagnostics = [
+    'anyUnknownInErrorContext',
+    'classSelfMismatch',
+    'duplicatePackage',
+    'effectFnImplicitAny',
+    'floatingEffect',
+    'genericEffectServices',
+    'missingEffectContext',
+    'missingEffectError',
+    'missingLayerContext',
+    'missingReturnYieldStar',
+    'missingStarInYieldEffectGen',
+    'nonObjectEffectServiceType',
+    'outdatedApi',
+    'overriddenSchemaConstructor',
+    'catchUnfailableEffect',
+    'effectFnIife',
+    'effectGenUsesAdapter',
+    'effectInFailure',
+    'effectInVoidSuccess',
+    'globalErrorInEffectCatch',
+    'globalErrorInEffectFailure',
+    'layerMergeAllWithDependencies',
+    'lazyPromiseInEffectSync',
+    'leakingRequirements',
+    'multipleEffectProvide',
+    'returnEffectInGen',
+    'runEffectInsideEffect',
+    'schemaSyncInEffect',
+    'scopeInLayerEffect',
+    'strictEffectProvide',
+    'tryCatchInEffectGen',
+    'unknownInEffectCatch',
+    'asyncFunction',
+    'cryptoRandomUUID',
+    'cryptoRandomUUIDInEffect',
+    'extendsNativeError',
+    'globalConsole',
+    'globalConsoleInEffect',
+    'globalDate',
+    'globalDateInEffect',
+    'globalFetch',
+    'globalFetchInEffect',
+    'globalRandom',
+    'globalRandomInEffect',
+    'globalTimers',
+    'globalTimersInEffect',
+    'instanceOfSchema',
+    'newPromise',
+    'nodeBuiltinImport',
+    'preferSchemaOverJson',
+    'processEnv',
+    'processEnvInEffect',
+    'unsafeEffectTypeAssertion',
+    'catchAllToMapError',
+    'deterministicKeys',
+    'effectDoNotation',
+    'effectFnOpportunity',
+    'effectMapFlatten',
+    'effectMapVoid',
+    'effectSucceedWithVoid',
+    'missedPipeableOpportunity',
+    'missingEffectServiceDependency',
+    'nestedEffectGenYield',
+    'redundantSchemaTagIdentifier',
+    'schemaStructWithTag',
+    'schemaUnionOfLiterals',
+    'serviceNotAsClass',
+    'strictBooleanExpressions',
+    'unnecessaryArrowBlock',
+    'unnecessaryEffectGen',
+    'unnecessaryFailYieldableError',
+    'unnecessaryPipe',
+    'unnecessaryPipeChain'
+];
+export { effectDiagnostics };

package/dist/esm-node/ultramodern-workspace/fs-io.js

@@ -0,0 +1,236 @@
+import "node:module";
+import { spawnSync } from "node:child_process";
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_os from "node:os";
+import node_path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { resolveCreatePackageRoot } from "../create-package-root.js";
+import { normalizePath } from "./naming.js";
+const fs_io_dirname = node_path.dirname(fileURLToPath(import.meta.url));
+const fs_io_require = createRequire(import.meta.url);
+const createPackageRoot = resolveCreatePackageRoot(fs_io_dirname);
+const workspaceTemplateDir = node_path.join(createPackageRoot, 'template-workspace');
+const fileTemplatesDir = node_path.join(createPackageRoot, 'templates');
+const preformatConfigDir = '.modern-js';
+const preformatConfigPath = node_path.join(preformatConfigDir, 'ultramodern-preformat.oxfmt.config.mjs');
+const workspaceOxfmtIgnorePatterns = [
+    '.agents',
+    '.codex/skills',
+    '.output',
+    '**/*.json',
+    'dist',
+    'node_modules',
+    'repos/**',
+    '.modern',
+    '.modernjs',
+    '**/modern-tanstack/**',
+    '**/routeTree.gen.*'
+];
+const formattableExtensions = new Set([
+    '.cjs',
+    '.cts',
+    '.js',
+    '.json',
+    '.jsonc',
+    '.jsx',
+    '.mjs',
+    '.mts',
+    '.md',
+    '.mdx',
+    '.ts',
+    '.tsx',
+    '.yaml',
+    '.yml'
+]);
+function readFileTemplate(relativePath) {
+    return node_fs.readFileSync(node_path.join(fileTemplatesDir, relativePath), 'utf-8');
+}
+function renderFileTemplate(relativePath, data) {
+    return renderTemplate(readFileTemplate(`${relativePath}.handlebars`), data);
+}
+function assertSafeRelativePath(relativePath) {
+    if (0 === relativePath.length || node_path.isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes('..')) throw new Error(`Unsafe workspace template path: ${relativePath}`);
+}
+function isPathInsideRoot(root, targetPath) {
+    const relativePath = node_path.relative(root, targetPath);
+    return '' === relativePath || !relativePath.startsWith('..') && !node_path.isAbsolute(relativePath);
+}
+function findExistingAncestor(targetPath) {
+    let currentPath = targetPath;
+    while(!node_fs.existsSync(currentPath)){
+        const parentPath = node_path.dirname(currentPath);
+        if (parentPath === currentPath) return;
+        currentPath = parentPath;
+    }
+    return currentPath;
+}
+function ensureInsideRoot(root, targetPath) {
+    const absoluteRoot = node_path.resolve(root);
+    const absoluteTargetPath = node_path.resolve(targetPath);
+    if (!isPathInsideRoot(absoluteRoot, absoluteTargetPath)) throw new Error(`Refusing to write outside workspace root: ${targetPath}`);
+    if (!node_fs.existsSync(absoluteRoot)) return;
+    const existingAncestor = findExistingAncestor(absoluteTargetPath);
+    if (!existingAncestor) return;
+    const rootRealPath = node_fs.realpathSync.native(absoluteRoot);
+    const ancestorRealPath = node_fs.realpathSync.native(existingAncestor);
+    const unresolvedRelativePath = node_path.relative(existingAncestor, absoluteTargetPath);
+    const resolvedTargetPath = node_path.resolve(ancestorRealPath, unresolvedRelativePath);
+    if (!isPathInsideRoot(rootRealPath, resolvedTargetPath)) throw new Error(`Refusing to write outside workspace root: ${targetPath}`);
+}
+function writeFile(targetDir, relativePath, content) {
+    assertSafeRelativePath(relativePath);
+    const filePath = node_path.join(targetDir, relativePath);
+    ensureInsideRoot(targetDir, filePath);
+    if (node_fs.existsSync(filePath)) throw new Error(`Refusing to overwrite generated workspace file: ${relativePath}`);
+    node_fs.mkdirSync(node_path.dirname(filePath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(filePath, content, 'utf-8');
+}
+function writeFileReplacing(targetDir, relativePath, content) {
+    assertSafeRelativePath(relativePath);
+    const filePath = node_path.join(targetDir, relativePath);
+    ensureInsideRoot(targetDir, filePath);
+    node_fs.mkdirSync(node_path.dirname(filePath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(filePath, content, 'utf-8');
+}
+function writeJson(targetDir, relativePath, value) {
+    writeFile(targetDir, relativePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function formatGeneratedSourceCandidates(sources) {
+    const temporaryRoot = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), 'ultramodern-format-'));
+    try {
+        sources.forEach(([relativePath, source])=>writeFileReplacing(temporaryRoot, relativePath, source));
+        const relativePaths = sources.map(([relativePath])=>relativePath);
+        formatGeneratedWorkspaceFiles(temporaryRoot, relativePaths);
+        return relativePaths.map((relativePath)=>node_fs.readFileSync(node_path.join(temporaryRoot, relativePath), 'utf-8'));
+    } finally{
+        node_fs.rmSync(temporaryRoot, {
+            force: true,
+            recursive: true
+        });
+    }
+}
+function formatGeneratedWorkspaceFiles(targetDir, relativePaths) {
+    const oxfmtBin = resolveOxfmtBin();
+    const oxfmtConfigPath = writePreformatConfig(targetDir);
+    const targets = void 0 === relativePaths ? [
+        targetDir,
+        `!${normalizePath(node_path.join(targetDir, 'repos'))}/**`
+    ] : relativePaths.filter((relativePath)=>formattableExtensions.has(node_path.extname(relativePath))).map((relativePath)=>node_path.join(targetDir, relativePath));
+    if (0 === targets.length) return void removePreformatConfig(targetDir);
+    try {
+        const result = spawnSync(process.execPath, [
+            oxfmtBin,
+            '--config',
+            oxfmtConfigPath,
+            '--no-error-on-unmatched-pattern',
+            ...targets
+        ], {
+            cwd: targetDir,
+            encoding: 'utf-8',
+            env: {
+                ...process.env,
+                FORCE_COLOR: '0'
+            }
+        });
+        if (0 !== result.status) {
+            const detail = [
+                result.stderr.trim(),
+                result.stdout.trim()
+            ].filter(Boolean).join('\n');
+            throw new Error([
+                'Failed to format generated UltraModern workspace output.',
+                detail
+            ].filter(Boolean).join('\n'));
+        }
+    } finally{
+        removePreformatConfig(targetDir);
+    }
+}
+function writePreformatConfig(targetDir) {
+    const configPath = node_path.join(targetDir, preformatConfigPath);
+    node_fs.mkdirSync(node_path.dirname(configPath), {
+        recursive: true
+    });
+    const oxfmtUrl = pathToFileURL(resolveOxfmtEntry()).href;
+    const ultraciteConfigUrl = pathToFileURL(resolveUltraciteOxfmtConfig()).href;
+    node_fs.writeFileSync(configPath, [
+        `import { defineConfig } from ${JSON.stringify(oxfmtUrl)};`,
+        `import ultracite from ${JSON.stringify(ultraciteConfigUrl)};`,
+        '',
+        'export default defineConfig({',
+        '  ...ultracite,',
+        '  ignorePatterns: [',
+        ...workspaceOxfmtIgnorePatterns.map((pattern)=>`    ${JSON.stringify(pattern)},`),
+        '  ],',
+        '  singleQuote: true,',
+        '});',
+        ''
+    ].join('\n'), 'utf-8');
+    return configPath;
+}
+function removePreformatConfig(targetDir) {
+    node_fs.rmSync(node_path.join(targetDir, preformatConfigPath), {
+        force: true
+    });
+    try {
+        node_fs.rmdirSync(node_path.join(targetDir, preformatConfigDir));
+    } catch  {}
+}
+function resolveOxfmtBin() {
+    const packageJsonPath = fs_io_require.resolve('oxfmt/package.json');
+    const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf-8'));
+    const binPath = 'string' == typeof packageJson.bin ? packageJson.bin : packageJson.bin?.oxfmt;
+    if ('string' != typeof binPath || 0 === binPath.length) throw new Error('Unable to resolve oxfmt binary from package metadata.');
+    return node_path.join(node_path.dirname(packageJsonPath), binPath);
+}
+function resolveOxfmtEntry() {
+    return fs_io_require.resolve('oxfmt');
+}
+function resolveUltraciteOxfmtConfig() {
+    return fs_io_require.resolve('ultracite/oxfmt');
+}
+function renderTemplate(template, data) {
+    return template.replace(/\{\{(\w+)\}\}/g, (match, key)=>data[key] ?? match);
+}
+function collectTemplateFiles(dir) {
+    const files = [];
+    function collect(currentDir) {
+        let entries;
+        try {
+            entries = node_fs.readdirSync(currentDir, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if ('ENOENT' === error.code) return;
+            throw error;
+        }
+        for (const entry of entries.sort((a, b)=>a.name.localeCompare(b.name))){
+            const entryPath = node_path.join(currentDir, entry.name);
+            if (entry.isDirectory()) collect(entryPath);
+            else if (entry.isFile()) files.push(normalizePath(node_path.relative(dir, entryPath)));
+        }
+    }
+    collect(dir);
+    return files;
+}
+function copyRootTemplate(targetDir, data, excludedRelativePaths = new Set()) {
+    for (const relativePath of collectTemplateFiles(workspaceTemplateDir)){
+        if (excludedRelativePaths.has(relativePath)) continue;
+        const sourcePath = node_path.join(workspaceTemplateDir, relativePath);
+        const outputPath = relativePath.replace(/\.handlebars$/, '');
+        const content = relativePath.endsWith('.handlebars') ? renderTemplate(node_fs.readFileSync(sourcePath, 'utf-8'), data) : node_fs.readFileSync(sourcePath, 'utf-8');
+        writeFile(targetDir, outputPath, content);
+    }
+}
+function readJsonFile(filePath) {
+    return JSON.parse(node_fs.readFileSync(filePath, 'utf-8'));
+}
+function writeJsonFile(filePath, value) {
+    node_fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+export { copyRootTemplate, createPackageRoot, formatGeneratedSourceCandidates, formatGeneratedWorkspaceFiles, readFileTemplate, readJsonFile, renderFileTemplate, renderTemplate, workspaceTemplateDir, writeFile, writeFileReplacing, writeJson, writeJsonFile };

package/dist/esm-node/ultramodern-workspace/generation-result.js

@@ -0,0 +1,133 @@
+import "node:module";
+import node_crypto from "node:crypto";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { rpcPath } from "./api/rpc.js";
+import { createDeliveryUnitRecord } from "./delivery-unit.js";
+import { apiSurface, exposeSurface } from "./delivery-unit-schema/up-projection.js";
+import { ULTRAMODERN_CONFIG_PATH, appHasApi, resolveApiProtocol } from "./descriptors.js";
+import { normalizePath, packageName } from "./naming.js";
+import { resolveOwnerAttribution } from "./types.js";
+import { EFFECT_VERSION, REACT_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_VERSION } from "./versions.js";
+const BASELINE_COHORT_ID = 'ultramodern-platform-baseline-v1';
+const ignoredSnapshotDirectories = new Set([
+    '.git',
+    '.nx',
+    '.output',
+    'coverage',
+    'dist',
+    'node_modules'
+]);
+function createFileSnapshot(root) {
+    const files = new Map();
+    if (!node_fs.existsSync(root)) return files;
+    function collect(currentDir) {
+        for (const entry of node_fs.readdirSync(currentDir, {
+            withFileTypes: true
+        }).sort((left, right)=>left.name.localeCompare(right.name))){
+            if (entry.isDirectory() && ignoredSnapshotDirectories.has(entry.name)) continue;
+            const entryPath = node_path.join(currentDir, entry.name);
+            if (entry.isDirectory()) collect(entryPath);
+            else if (entry.isFile()) {
+                const relativePath = normalizePath(node_path.relative(root, entryPath));
+                files.set(relativePath, hashFile(entryPath));
+            }
+        }
+    }
+    collect(root);
+    return files;
+}
+function diffFileSnapshots(before, after) {
+    const createdPaths = [];
+    const rewrittenPaths = [];
+    for (const [relativePath, hash] of after){
+        const previousHash = before.get(relativePath);
+        if (void 0 === previousHash) createdPaths.push(relativePath);
+        else if (previousHash !== hash) rewrittenPaths.push(relativePath);
+    }
+    return {
+        createdPaths: createdPaths.sort(),
+        rewrittenPaths: rewrittenPaths.sort()
+    };
+}
+function createGenerationResult(options) {
+    const createdApps = options.createdApps.map((app)=>createGeneratedAppDescriptor(options.packageScope, app));
+    return {
+        operation: options.operation,
+        workspaceRoot: options.workspaceRoot,
+        packageScope: options.packageScope,
+        packageSource: {
+            ...options.packageSource
+        },
+        createdApps,
+        createdPaths: [
+            ...options.createdPaths
+        ].sort(),
+        rewrittenPaths: [
+            ...options.rewrittenPaths
+        ].sort(),
+        assignedPorts: Object.fromEntries(createdApps.map((app)=>[
+                app.id,
+                app.port
+            ])),
+        moduleFederationNames: Object.fromEntries(createdApps.map((app)=>[
+                app.id,
+                app.moduleFederationName
+            ])),
+        apiPrefixes: Object.fromEntries(createdApps.filter((app)=>app.apiPrefix).map((app)=>[
+                app.id,
+                app.apiPrefix
+            ])),
+        generatedContractPath: ULTRAMODERN_CONFIG_PATH,
+        warnings: options.warnings ?? [],
+        deliveryUnits: options.createdApps.map((app)=>createGeneratedDeliveryUnitDescriptor(options.packageScope, app))
+    };
+}
+function createGeneratedDeliveryUnitDescriptor(scope, app) {
+    const record = createDeliveryUnitRecord(scope, app);
+    const surfaces = Object.entries(app.exposes ?? {}).map(([key, value])=>exposeSurface(app, key, value));
+    if (appHasApi(app)) surfaces.push(apiSurface(app.api, resolveApiProtocol(app), 'rpc' === resolveApiProtocol(app) ? rpcPath(app) : app.api.prefix));
+    const canonicalKind = 'shell' === app.kind ? 'shell' : app.deliveryUnitKind ?? 'microvertical';
+    return {
+        unitId: record.unitId,
+        kind: canonicalKind,
+        owner: resolveOwnerAttribution(app.ownership),
+        sourceRevision: record.sourceRevision,
+        buildMarker: record.buildMarker,
+        baselineCohort: {
+            cohortId: BASELINE_COHORT_ID,
+            resolved: {
+                react: REACT_VERSION,
+                tanstackRouter: TANSTACK_ROUTER_VERSION,
+                effect: EFFECT_VERSION,
+                tailwind: TAILWIND_VERSION
+            }
+        },
+        surfaces
+    };
+}
+function createGeneratedAppDescriptor(scope, app) {
+    return {
+        id: app.id,
+        directory: app.directory,
+        packageName: packageName(scope, app.packageSuffix),
+        packageSuffix: app.packageSuffix,
+        displayName: app.displayName,
+        kind: app.kind,
+        portEnv: app.portEnv,
+        port: app.port,
+        moduleFederationName: app.mfName,
+        ...app.exposes ? {
+            exposes: {
+                ...app.exposes
+            }
+        } : {},
+        ...appHasApi(app) ? {
+            apiPrefix: app.api.prefix
+        } : {}
+    };
+}
+function hashFile(filePath) {
+    return node_crypto.createHash('sha256').update(node_fs.readFileSync(filePath)).digest('hex');
+}
+export { createFileSnapshot, createGenerationResult, diffFileSnapshots, ignoredSnapshotDirectories };

package/dist/esm-node/ultramodern-workspace/index.js

@@ -0,0 +1,8 @@
+import "node:module";
+export { addUltramodernShell, planUltramodernShell } from "./add-shell.js";
+export { addUltramodernVertical, planUltramodernVertical } from "./add-vertical.js";
+export { normalizeUltramodernBridgeConfig } from "./bridge-config.js";
+export { BASELINE_DEPENDENCY_PINS, OverlayBaselineRelaxationError } from "./overlay-baseline-guard.js";
+export { SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES } from "./shared-patches.js";
+export { PRIMARY_SHELL_ID, createShellDescriptor, resolveConfiguredAdditionalShells } from "./shells.js";
+export { generateUltramodernWorkspace } from "./write-workspace.js";