@bleedingdev/modern-js-ultramodern-create 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

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

@@ -1,16 +1,11 @@
 import "node:module";
-import { ULTRAMODERN_CREATE_PACKAGE } from "../ultramodern-package-source.js";
 import { apiTopologyMetadata } from "./api.js";
 import { rpcPath } from "./api/rpc.js";
-import { createBackendFederationContract, createBackendFederationSummary, createServerExecutionOverlay } from "./backend-federation.js";
-import { defaultReactSingletons } from "./bridge-config/defaults.js";
+import { createBackendFederationContract, createServerExecutionOverlay } from "./backend-federation.js";
 import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-unit.js";
 import { appEmitsBrowserUi, createModuleFederationRemoteContracts, createShellHost, resolveApiPrefix, resolveApiProtocol, sharedPackages, shellApp, verticalApiApps } from "./descriptors.js";
 import { packageName } from "./naming.js";
 import { createCloudflareDeployContract } from "./policy.js";
-import { createAdditionalShellConfigEntry } from "./shells.js";
-import { createGeneratedToolingWrapperMap } from "./tooling-command-catalog.js";
-import { CLOUDFLARE_COMPATIBILITY_DATE, NODE_VERSION, PNPM_VERSION } from "./versions.js";
 function isJsonValue(value) {
     return void 0 !== value;
 }
@@ -22,9 +17,6 @@ function optionalJsonEntry(key, value) {
 function jsonEntries(entries) {
     return Object.fromEntries(entries.filter((entry)=>isJsonValue(entry[1])));
 }
-function presentJsonValues(values) {
-    return values.filter(isJsonValue);
-}
 function createReferenceRemoteContracts(app, remotes) {
     return createModuleFederationRemoteContracts(app, remotes).map((remote)=>({
             id: remote.id,
@@ -40,20 +32,23 @@ function createTopology(scope, remotes = [], primaryShell) {
         description: 'Generated UltraModern SuperApp shell that can grow by adding full-stack verticals.',
         preset: 'presetUltramodern',
         shell: {
-            id: shellApp.id,
+            id: shellHost.id,
             kind: 'shell',
-            package: packageName(scope, shellApp.packageSuffix),
+            package: packageName(scope, shellHost.packageSuffix),
+            path: shellHost.directory,
+            displayName: shellHost.displayName,
+            portEnv: shellHost.portEnv,
             verticalRefs: shellHost.verticalRefs ?? [],
             moduleFederation: {
                 role: 'host',
-                name: shellApp.mfName,
+                name: shellHost.mfName,
                 remotes: createReferenceRemoteContracts(shellHost, remotes),
                 ssr: true,
                 sharedContractVersion: 'mf-ssr-contract-v1'
             },
-            deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, shellApp)),
-            cloudflare: createCloudflareDeployContract(scope, shellApp),
-            ownership: shellApp.ownership
+            deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, shellHost)),
+            cloudflare: createCloudflareDeployContract(scope, shellHost),
+            ownership: shellHost.ownership
         },
         verticals: remotes.map((vertical)=>({
                 id: vertical.id,
@@ -69,6 +64,8 @@ function createTopology(scope, remotes = [], primaryShell) {
                 } : {},
                 package: packageName(scope, vertical.packageSuffix),
                 path: vertical.directory,
+                displayName: vertical.displayName,
+                portEnv: vertical.portEnv,
                 moduleFederation: {
                     role: 'remote',
                     name: vertical.mfName,
@@ -92,15 +89,7 @@ function createTopology(scope, remotes = [], primaryShell) {
                 package: packageName(scope, sharedPackage.id),
                 path: sharedPackage.directory,
                 description: sharedPackage.description
-            })),
-        validation: {
-            script: "scripts/validate-ultramodern-workspace.mts",
-            commands: [
-                'pnpm i18n:boundaries',
-                'pnpm api:check',
-                'pnpm contract:check'
-            ]
-        }
+            }))
     };
 }
 function createOwnership(scope, remotes = []) {
@@ -162,159 +151,4 @@ function createDevelopmentOverlay(scope, remotes = []) {
             ]))
     };
 }
-function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
-    createShellHost()
-], enableTailwind = true, bridge, additionalShells = [], primaryShell) {
-    const remotes = apps.filter((app)=>'shell' !== app.kind);
-    const shellHost = primaryShell ?? createShellHost(remotes);
-    return {
-        schemaVersion: 1,
-        profile: 'cloudflare-ssr-mf-effect-v1',
-        generator: {
-            package: ULTRAMODERN_CREATE_PACKAGE,
-            version: modernVersion
-        },
-        workspace: {
-            packageScope: scope,
-            packageManager: {
-                name: 'pnpm',
-                version: PNPM_VERSION
-            },
-            node: {
-                version: NODE_VERSION,
-                engineRange: '>=26'
-            }
-        },
-        packageSource: {
-            strategy: packageSource.strategy,
-            modernPackageVersion: packageSource.modernPackageVersion,
-            ...packageSource.registry ? {
-                registry: packageSource.registry
-            } : {},
-            ...packageSource.aliasScope ? {
-                aliasScope: packageSource.aliasScope
-            } : {},
-            ...packageSource.aliasPackageNamePrefix ? {
-                aliasPackageNamePrefix: packageSource.aliasPackageNamePrefix
-            } : {}
-        },
-        features: {
-            tailwind: enableTailwind
-        },
-        topology: {
-            source: './topology/reference-topology.json',
-            apps: apps.map((app)=>({
-                    id: app.id,
-                    kind: app.kind,
-                    package: packageName(scope, app.packageSuffix),
-                    packageSuffix: app.packageSuffix,
-                    displayName: app.displayName,
-                    path: app.directory,
-                    ...app.domain ? {
-                        domain: app.domain
-                    } : {},
-                    ...app.surfaceProfile ? {
-                        surfaceProfile: app.surfaceProfile
-                    } : {},
-                    ...app.deliveryUnitKind ? {
-                        deliveryUnitKind: app.deliveryUnitKind
-                    } : {},
-                    port: app.port,
-                    portEnv: app.portEnv,
-                    moduleFederation: {
-                        role: 'shell' === app.kind ? 'host' : 'remote',
-                        name: app.mfName,
-                        exposes: Object.keys(app.exposes ?? {}),
-                        ...'shell' === app.kind ? {
-                            verticalRefs: shellHost.verticalRefs ?? [],
-                            remotes: createModuleFederationRemoteContracts(shellHost, remotes)
-                        } : app.verticalRefs?.length ? {
-                            verticalRefs: app.verticalRefs,
-                            remotes: createModuleFederationRemoteContracts(app, remotes)
-                        } : {},
-                        ssr: true,
-                        dts: {
-                            compilerInstance: 'effect-tsgo',
-                            tsConfigPath: './tsconfig.mf-types.json'
-                        }
-                    },
-                    ...optionalJsonEntry('backendFederation', createBackendFederationContract(scope, app)),
-                    deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, app)),
-                    ...app.api ? {
-                        api: {
-                            runtime: 'effect',
-                            stem: app.api.stem,
-                            prefix: app.api.prefix,
-                            consumedBy: app.api.consumedBy,
-                            serverEntry: `${app.directory}/api/index.ts`,
-                            ...void 0 === app.api.protocol ? {} : {
-                                protocol: app.api.protocol
-                            }
-                        }
-                    } : {},
-                    deploy: {
-                        cloudflare: createCloudflareDeployContract(scope, app)
-                    }
-                }))
-        },
-        ...additionalShells.length > 0 ? {
-            shells: additionalShells.map((shell)=>createAdditionalShellConfigEntry(scope, shell, remotes))
-        } : {},
-        bridge: bridge ?? {
-            enabled: false,
-            workspacePackages: [],
-            dependencies: [],
-            lockfilePolicy: 'nested',
-            gates: [],
-            reactSingletons: [
-                ...defaultReactSingletons
-            ]
-        },
-        deploy: {
-            worker: {
-                wrangler: {
-                    compatibility_date: CLOUDFLARE_COMPATIBILITY_DATE,
-                    compatibility_flags: [
-                        'nodejs_compat',
-                        'global_fetch_strictly_public'
-                    ]
-                },
-                artifacts: [],
-                publicAssetExcludes: []
-            }
-        },
-        moduleFederation: {
-            apps: apps.map((app)=>({
-                    id: app.id,
-                    path: app.directory,
-                    role: 'shell' === app.kind ? 'host' : 'remote',
-                    name: app.mfName,
-                    exposes: Object.keys(app.exposes ?? {}),
-                    hostOnly: 'shell' === app.kind && 0 === Object.keys(app.exposes ?? {}).length
-                }))
-        },
-        backendFederation: {
-            apps: presentJsonValues(verticalApiApps(remotes).map((app)=>createBackendFederationSummary(scope, app)))
-        },
-        agentSkills: {
-            target: 'codex',
-            lockfile: './.codex/skills-lock.json',
-            installDir: './.codex/skills',
-            mode: 'repo-owned-default-on',
-            selfContainedVendoring: true,
-            optOutEnv: [
-                'ULTRAMODERN_SKIP_CODEX_SKILLS=1',
-                'ULTRAMODERN_CODEX_SKILLS=0'
-            ]
-        },
-        tooling: {
-            command: 'ultramodern-create ultramodern',
-            wrappers: {
-                ...createGeneratedToolingWrapperMap(),
-                apiBoundaries: "scripts/check-ultramodern-api-boundaries.mts",
-                skills: "scripts/bootstrap-agent-skills.mts"
-            }
-        }
-    };
-}
-export { createDevelopmentOverlay, createOwnership, createTopology, createUltramodernConfig };
+export { createDevelopmentOverlay, createOwnership, createTopology };

package/dist/esm-node/ultramodern-workspace/delivery-unit-schema/surfaces.js

@@ -0,0 +1,42 @@
+import "node:module";
+const SEGMENT_UNSAFE = /[^A-Za-z0-9._-]+/g;
+const SEGMENT_TRIM = /^-+|-+$/g;
+function exposeSurfaceId(key) {
+    const trimmed = key.replace(/^\.\//, '');
+    const cleaned = trimmed.replace(SEGMENT_UNSAFE, '-').replace(SEGMENT_TRIM, '');
+    return '' === cleaned ? 'surface' : cleaned;
+}
+function exposeSurface(app, key, value) {
+    const isRoute = /route/i.test(key) || /route/i.test(value);
+    const location = {
+        platform: 'browser-mf',
+        manifestUrl: `http://localhost:${app.port}/mf-manifest.json`
+    };
+    const common = {
+        surfaceId: exposeSurfaceId(key),
+        locations: [
+            location
+        ]
+    };
+    return isRoute ? {
+        kind: 'route',
+        ...common
+    } : {
+        kind: 'component',
+        ...common
+    };
+}
+function apiSurface(api, protocol, address = api.prefix) {
+    return {
+        kind: 'api',
+        surfaceId: api.stem,
+        protocol,
+        locations: [
+            {
+                platform: 'http',
+                address
+            }
+        ]
+    };
+}
+export { apiSurface, exposeSurface, exposeSurfaceId };

package/dist/esm-node/ultramodern-workspace/delivery-unit-schema/types.js

@@ -1,6 +1,4 @@
 import "node:module";
-import { DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION } from "@modern-js/utils/universal";
-import { isVerticalApiProtocol } from "../types.js";
 const SEGMENT_PATTERN = /^[A-Za-z0-9._-]+$/;
 const MAJOR_PATTERN = /^v[1-9][0-9]*$/;
 function parseSurfaceRef(input) {
@@ -159,79 +157,7 @@ function serializeDeliveryUnitDescriptor(descriptor) {
     };
     return output;
 }
-function projectKind(kind) {
-    switch(kind){
-        case 'shell':
-            return 'shell';
-        case 'microvertical':
-        case 'horizontal-remote':
-            return 'vertical';
-        default:
-            return assertNever(kind);
-    }
-}
-function lastSegment(unitId) {
-    const segments = unitId.split('/');
-    return segments[segments.length - 1] ?? unitId;
-}
-function projectApi(surfaces, mode) {
-    const apiSurface = surfaces.find((surface)=>'api' === surface.kind);
-    if (void 0 === apiSurface) return;
-    const http = apiSurface.locations.find((location)=>'http' === location.platform);
-    return {
-        stem: apiSurface.surfaceId,
-        prefix: http?.address ?? `/${apiSurface.surfaceId}`,
-        consumedBy: [],
-        ...'extended-v1' === mode && isVerticalApiProtocol(apiSurface.protocol) ? {
-            protocol: apiSurface.protocol
-        } : {}
-    };
-}
-function projectDeliveryUnitToV1(descriptor, context) {
-    const appId = lastSegment(descriptor.unitId);
-    const mode = context.mode ?? 'strict-legacy';
-    const api = projectApi(descriptor.surfaces, mode);
-    const ownership = 'team' === descriptor.owner.kind ? context.ownership : {
-        ...context.ownership,
-        owner: {
-            ...descriptor.owner
-        }
-    };
-    const app = {
-        id: appId,
-        directory: context.directory,
-        packageSuffix: context.packageSuffix,
-        displayName: context.displayName,
-        kind: projectKind(descriptor.kind),
-        portEnv: context.portEnv,
-        port: context.port,
-        mfName: context.mfName,
-        ownership,
-        ...'extended-v1' === mode && 'horizontal-remote' === descriptor.kind ? {
-            deliveryUnitKind: 'horizontal-remote'
-        } : {},
-        ...void 0 === api ? {} : {
-            api
-        }
-    };
-    const deliveryUnitRecord = {
-        appId,
-        buildMarker: descriptor.buildMarker,
-        deployProfile: DELIVERY_UNIT_DEPLOY_PROFILE,
-        kind: DELIVERY_UNIT_KIND,
-        packageName: context.packageName,
-        schemaVersion: DELIVERY_UNIT_SCHEMA_VERSION,
-        sourceRevision: descriptor.sourceRevision,
-        unitId: descriptor.unitId,
-        version: context.version
-    };
-    return {
-        app,
-        deliveryUnitRecord,
-        preservedUnknownFields: descriptor.unknownFields ?? {}
-    };
-}
 function assertNever(value) {
     throw new Error(`Unexpected variant: ${JSON.stringify(value)}`);
 }
-export { assertNever, formatSurfaceRef, parseDeliveryUnitDescriptor, parseSurfaceRef, projectDeliveryUnitToV1, resolvePublicationZone, serializeDeliveryUnitDescriptor };
+export { assertNever, formatSurfaceRef, parseDeliveryUnitDescriptor, parseSurfaceRef, resolvePublicationZone, serializeDeliveryUnitDescriptor };

package/dist/esm-node/ultramodern-workspace/delivery-unit-stamp.js

@@ -4,16 +4,28 @@ import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-
 function isPlainObject(value) {
     return 'object' == typeof value && null !== value && !Array.isArray(value);
 }
-function stampDeliveryUnitIdentity(entry, scope, app) {
-    const block = deliveryUnitContractBlock(createDeliveryUnitRecord(scope, app));
+function stampDeliveryUnitIdentity(entry, scope, app, version) {
+    const block = {
+        ...isPlainObject(entry.deliveryUnit) ? entry.deliveryUnit : {},
+        ...deliveryUnitContractBlock(createDeliveryUnitRecord(scope, app, version))
+    };
     entry.deliveryUnit = block;
     if (isPlainObject(entry.backendFederation)) {
-        entry.backendFederation.deliveryUnit = block;
+        entry.backendFederation.deliveryUnit = {
+            ...isPlainObject(entry.backendFederation.deliveryUnit) ? entry.backendFederation.deliveryUnit : {},
+            ...block
+        };
         if (!isPlainObject(entry.backendFederation.versionBoundary)) entry.backendFederation.versionBoundary = {};
         entry.backendFederation.versionBoundary.identityRoot = 'deliveryUnit';
         return;
     }
-    const contract = createBackendFederationContract(scope, app);
+    const contract = createBackendFederationContract(scope, {
+        ...app,
+        deliveryUnit: {
+            ...app.deliveryUnit,
+            ...block
+        }
+    });
     if (void 0 !== contract) entry.backendFederation = contract;
 }
 export { isPlainObject, stampDeliveryUnitIdentity };

package/dist/esm-node/ultramodern-workspace/delivery-unit-sync.js

@@ -2,9 +2,9 @@ import "node:module";
 import node_fs from "node:fs";
 import node_path from "node:path";
 import { parseArgs } from "node:util";
-import { readUltramodernConfig, workspaceAppsFromToolingConfig } from "../ultramodern-tooling/config.js";
+import { readUltramodernWorkspaceInputs } from "../ultramodern-tooling/config.js";
+import { createBuildMarker } from "./delivery-unit.js";
 import { isPlainObject, stampDeliveryUnitIdentity } from "./delivery-unit-stamp.js";
-import { ULTRAMODERN_CONFIG_PATH } from "./descriptors.js";
 import { createUltramodernBuildArtifactJson, createUltramodernBuildModule } from "./module-federation.js";
 const REFERENCE_TOPOLOGY_PATH = 'topology/reference-topology.json';
 function writeTextIfChanged(absolutePath, content) {
@@ -40,8 +40,8 @@ function runSyncDeliveryUnit(args, context) {
 Backfills the per-delivery-unit identity blocks required by
 \`ultramodern validate\` onto an existing generated workspace, in place and
 through framework tooling only. For each delivery unit it writes the
-delivery-unit block into .modernjs/ultramodern.json topology.apps[] and
-topology/reference-topology.json verticals[] (plus backendFederation.deliveryUnit
+delivery-unit block into topology/reference-topology.json shell/verticals/shells
+(plus backendFederation.deliveryUnit
 and backendFederation.versionBoundary.identityRoot) and regenerates
 <app>/shared/ultramodern-build.{json,ts}. Idempotent: a second run writes
 nothing.
@@ -50,11 +50,23 @@ nothing.
     }
     const workspaceOverride = parsed.values.workspace;
     const workspaceRoot = workspaceOverride ? node_path.resolve(context.invocationCwd, workspaceOverride) : context.workspaceRoot;
-    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
-    if (!node_fs.existsSync(compactPath)) throw new Error(`Missing ${ULTRAMODERN_CONFIG_PATH}. sync-delivery-unit needs the compact UltraModern config; run \`ultramodern-create ultramodern migrate-strict-effect\` first.`);
-    const config = readUltramodernConfig(workspaceRoot);
-    const scope = config.workspace.packageScope;
-    const workspaceApps = workspaceAppsFromToolingConfig(config);
+    const workspace = readUltramodernWorkspaceInputs(workspaceRoot);
+    const scope = workspace.config.workspace.packageScope;
+    const packageVersions = new Map();
+    const workspaceApps = workspace.apps.map((app)=>{
+        const manifestPath = node_path.join(workspaceRoot, app.directory, 'package.json');
+        const manifest = JSON.parse(node_fs.readFileSync(manifestPath, 'utf-8'));
+        if ('string' != typeof manifest.version || !manifest.version) throw new Error(`${manifestPath} requires a package version for delivery-unit sync.`);
+        packageVersions.set(app.id, manifest.version);
+        return {
+            ...app,
+            deliveryUnit: {
+                ...app.deliveryUnit,
+                version: manifest.version,
+                buildMarker: createBuildMarker(scope, app, manifest.version)
+            }
+        };
+    });
     const written = [];
     const unchanged = [];
     const track = (relativePath, changed)=>{
@@ -64,24 +76,22 @@ nothing.
             app.id,
             app
         ]));
-    const compact = JSON.parse(node_fs.readFileSync(compactPath, 'utf-8'));
-    if (isPlainObject(compact) && Array.isArray(compact.topology?.apps)) for (const entry of compact.topology.apps){
-        if (!isPlainObject(entry)) continue;
-        const app = appById.get(String(entry.id));
-        if (app) stampDeliveryUnitIdentity(entry, scope, app);
-    }
-    track(ULTRAMODERN_CONFIG_PATH, writeJsonIfChanged(compactPath, compact));
     const topologyPath = node_path.join(workspaceRoot, REFERENCE_TOPOLOGY_PATH);
     if (node_fs.existsSync(topologyPath)) {
         const topology = JSON.parse(node_fs.readFileSync(topologyPath, 'utf-8'));
         if (isPlainObject(topology) && Array.isArray(topology.verticals)) for (const entry of topology.verticals){
             if (!isPlainObject(entry)) continue;
             const app = appById.get(String(entry.id));
-            if (app) stampDeliveryUnitIdentity(entry, scope, app);
+            if (app) stampDeliveryUnitIdentity(entry, scope, app, packageVersions.get(app.id));
+        }
+        if (isPlainObject(topology) && Array.isArray(topology.shells)) for (const entry of topology.shells){
+            if (!isPlainObject(entry)) continue;
+            const app = appById.get(String(entry.id));
+            if (app) stampDeliveryUnitIdentity(entry, scope, app, packageVersions.get(app.id));
         }
         if (isPlainObject(topology) && isPlainObject(topology.shell)) {
             const shell = appById.get(String(topology.shell.id));
-            if (shell) stampDeliveryUnitIdentity(topology.shell, scope, shell);
+            if (shell) stampDeliveryUnitIdentity(topology.shell, scope, shell, packageVersions.get(shell.id));
         }
         track(REFERENCE_TOPOLOGY_PATH, writeJsonIfChanged(topologyPath, topology));
     }

package/dist/esm-node/ultramodern-workspace/delivery-unit.js

@@ -1,22 +1,28 @@
 import "node:module";
 import node_crypto from "node:crypto";
-import { DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, deliveryUnitContractBlock } from "@modern-js/utils/universal";
+import { DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, deliveryUnitContractBlock } from "@modern-js/backend-federation-contracts";
 import { packageName } from "./naming.js";
 const deliveryUnitGenerationSeed = 'ultramodern-delivery-unit-build-marker:v1';
-function createBuildMarker(scope, app) {
-    return node_crypto.createHash('sha256').update(`${deliveryUnitGenerationSeed}:${scope}:${app.packageSuffix}:${app.id}:0.1.0`).digest('hex').slice(0, 16);
+function createBuildMarker(scope, app, version = '0.1.0') {
+    return node_crypto.createHash('sha256').update(`${deliveryUnitGenerationSeed}:${scope}:${app.packageSuffix}:${app.id}:${version}`).digest('hex').slice(0, 16);
 }
-function createDeliveryUnitRecord(scope, app) {
+function createDeliveryUnitRecord(scope, app, version) {
+    const resolvedVersion = version ?? '0.1.0';
     return {
         appId: app.id,
-        buildMarker: createBuildMarker(scope, app),
+        buildMarker: createBuildMarker(scope, app, resolvedVersion),
         deployProfile: DELIVERY_UNIT_DEPLOY_PROFILE,
         kind: DELIVERY_UNIT_KIND,
         packageName: packageName(scope, app.packageSuffix),
         schemaVersion: DELIVERY_UNIT_SCHEMA_VERSION,
         sourceRevision: 'workspace',
         unitId: `${scope}/${app.domain ?? app.id}`,
-        version: '0.1.0'
+        version: resolvedVersion,
+        ...app.deliveryUnit,
+        ...void 0 === version ? {} : {
+            version,
+            buildMarker: createBuildMarker(scope, app, version)
+        }
     };
 }
 export { createBuildMarker, createDeliveryUnitRecord, deliveryUnitContractBlock };