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

package/dist/esm-node/ultramodern-workspace/validation/assertions.js

@@ -0,0 +1,66 @@
+import "node:module";
+function assert(condition, message) {
+    if (!condition) throw new Error(message);
+}
+const canonicalizeJson = (value)=>{
+    if (Array.isArray(value)) {
+        const entries = value.map(canonicalizeJson);
+        const keyedEntries = entries.every((entry)=>null !== entry && 'object' == typeof entry && !Array.isArray(entry) && 'id' in entry && 'string' == typeof entry.id);
+        if (keyedEntries) {
+            const ids = entries.map((entry)=>entry.id);
+            if (new Set(ids).size === ids.length) return entries.toSorted((left, right)=>left.id.localeCompare(right.id));
+        }
+        return entries;
+    }
+    if (null !== value && 'object' == typeof value) return Object.fromEntries(Object.keys(value).toSorted().map((key)=>[
+            key,
+            canonicalizeJson(value[key])
+        ]));
+    return value;
+};
+const sameJson = (actual, expected)=>JSON.stringify(canonicalizeJson(actual)) === JSON.stringify(canonicalizeJson(expected));
+const formatJson = (value)=>void 0 === value ? 'undefined' : JSON.stringify(canonicalizeJson(value));
+const selfCheckFailure = (contract, message, fixArea)=>`MicroVertical contract self-check failed: ${contract}. ${message}. Fix area: ${fixArea}.`;
+function assertSelfCheck(condition, contract, message, fixArea) {
+    assert(condition, selfCheckFailure(contract, message, fixArea));
+}
+const assertSameJson = (actual, expected, contract, fixArea)=>{
+    assertSelfCheck(sameJson(actual, expected), contract, `Expected ${formatJson(expected)}, found ${formatJson(actual)}`, fixArea);
+};
+const assertIncludesJson = (actual, required, contract, fixArea)=>{
+    assertArray(actual, contract, fixArea);
+    for (const entry of required)assertSelfCheck(actual.some((value)=>sameJson(value, entry)), contract, `Missing required entry ${formatJson(entry)}`, fixArea);
+};
+function assertObject(value, contract, fixArea) {
+    assertSelfCheck(null !== value && 'object' == typeof value && !Array.isArray(value), contract, `Expected JSON object, found ${formatJson(value)}`, fixArea);
+}
+function assertArray(value, contract, fixArea) {
+    assertSelfCheck(Array.isArray(value), contract, `Expected JSON array, found ${formatJson(value)}`, fixArea);
+}
+const assertUniqueStrings = (values, contract)=>{
+    assert(Array.isArray(values), `${contract} must be an array`);
+    const seen = new Set();
+    for (const value of values){
+        assert('string' == typeof value && value.length > 0, `${contract} must contain non-empty strings`);
+        assert(!seen.has(value), `Duplicate value "${value}" in ${contract}`);
+        seen.add(value);
+    }
+};
+const assertUniqueIdEntries = (entries, contract)=>{
+    assert(Array.isArray(entries), `${contract} must be an array`);
+    const seen = new Set();
+    for (const entry of entries){
+        const id = entry?.id;
+        assert('string' == typeof id && id.length > 0, `${contract} entries must have non-empty string ids`);
+        assert(!seen.has(id), `Duplicate id "${id}" in ${contract}`);
+        seen.add(id);
+    }
+};
+const assertSameIdCohort = (entries, expectedIds, contract, fixArea)=>{
+    assert(entries && expectedIds, `${contract} must be an array`);
+    assertUniqueIdEntries(entries, contract);
+    assertSameJson(entries.map((entry)=>entry.id).toSorted(), [
+        ...expectedIds
+    ].toSorted(), `${contract} cohort`, fixArea);
+};
+export { assert, assertArray, assertIncludesJson, assertObject, assertSameIdCohort, assertSameJson, assertSelfCheck, assertUniqueIdEntries, assertUniqueStrings, canonicalizeJson, formatJson, sameJson, selfCheckFailure };

package/dist/esm-node/ultramodern-workspace/validation/types.js

@@ -0,0 +1 @@
+import "node:module";

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

@@ -0,0 +1,287 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { yaml } from "@modern-js/utils";
+import { hasCreateReleaseCohort, isCreatePackageSourceCheckout, readCreateReleaseCohort } from "../../ultramodern-release-cohort.js";
+import { assertCompilerArchitecture } from "./architecture.js";
+function assert(condition, message) {
+    if (!condition) throw new Error(message);
+}
+function record(value, label) {
+    assert(null !== value && 'object' == typeof value && !Array.isArray(value), `${label} must be an object`);
+    return value;
+}
+function entries(value, label) {
+    assert(Array.isArray(value), `${label} must be an array`);
+    return value.map((entry, index)=>record(entry, `${label}[${index}]`));
+}
+function distinct(values, label) {
+    assert(new Set(values).size === values.length, `${label} contains duplicate entries`);
+}
+function requiredFile(root, relative, label) {
+    assert(node_fs.existsSync(node_path.join(root, relative)), `${label} is missing: ${relative}`);
+}
+function developmentUrl(value, port, label, generatedPath) {
+    assert('string' == typeof value, `${label} must be a URL`);
+    let parsed;
+    try {
+        parsed = new URL(value);
+    } catch  {
+        throw new Error(`${label} must be a URL`);
+    }
+    assert([
+        'http:',
+        'https:'
+    ].includes(parsed.protocol) && parsed.hostname.length > 0, `${label} must be an HTTP URL`);
+    if (generatedPath && parsed.pathname === generatedPath && ('localhost' === parsed.hostname || '127.0.0.1' === parsed.hostname)) assert(Number(parsed.port) === port, `${label} must use the app development port ${port}`);
+    return parsed;
+}
+function safePath(root, relative, label) {
+    assert('string' == typeof relative && relative.length > 0 && !node_path.isAbsolute(relative), `${label} must be a relative path`);
+    const resolved = node_path.resolve(root, relative);
+    assert(resolved.startsWith(`${node_path.resolve(root)}${node_path.sep}`), `${label} leaves the workspace`);
+    const realRoot = node_fs.realpathSync(root);
+    const real = node_fs.realpathSync(resolved);
+    assert(real.startsWith(`${realRoot}${node_path.sep}`), `${label} resolves outside the workspace`);
+    return resolved;
+}
+function validateApiClientExports(root, appPath, appId, exports) {
+    const clients = [
+        './api/client',
+        './api/rpc-client'
+    ].map((key)=>exports?.[key]).filter((value)=>void 0 !== value);
+    assert(clients.length > 0, `${appId} must export its API client`);
+    for (const client of clients){
+        assert('string' == typeof client && client.startsWith('./') && !client.split(/[\\/]/u).includes('..') && /\.[cm]?[jt]sx?$/u.test(client), `${appId} must export its API client from an app-owned source module`);
+        assert(node_fs.existsSync(node_path.join(root, appPath, client)), `${appId} API client is missing: ${client}`);
+        const clientFile = safePath(node_path.join(root, appPath), client, `${appId} API client`);
+        assert(node_fs.statSync(clientFile).isFile(), `${appId} API client must be a file`);
+    }
+}
+function validateApiOnlySourceSurface(root, app) {
+    assert(!Object.hasOwn(app.backendFederation?.versionBoundary ?? {}, 'ui'), `topology/reference-topology.json verticals.${app.id}.backendFederation must omit the UI boundary for an api-only unit`);
+    for (const relative of [
+        'module-federation.config.ts',
+        'src/federation-entry.tsx',
+        `src/components/${app.id}-widget.tsx`,
+        'src/routes/layout.tsx',
+        'src/routes/[lang]/page.tsx',
+        'src/routes/[lang]/route.meta.ts',
+        'src/routes/ultramodern-route-metadata.ts',
+        'src/routes/ultramodern-route-head.tsx',
+        'src/routes/index.css'
+    ])assert(!node_fs.existsSync(node_path.join(root, app.path, relative)), `Unexpected ${app.path}/${relative} for a api-only unit`);
+    const mfTypesPath = node_path.join(root, app.path, 'tsconfig.mf-types.json');
+    if (node_fs.existsSync(mfTypesPath)) {
+        const mfTypes = record(JSON.parse(node_fs.readFileSync(mfTypesPath, 'utf8')), `${app.id} tsconfig.mf-types.json`);
+        assert(!mfTypes.include?.includes('src/federation-entry.tsx'), `${app.id}: restore the generated MicroVertical Module Federation DTS boundary`);
+    }
+}
+function validateBackendFederationEntrypoints(root, appPath, appId) {
+    for (const relative of [
+        'backend-federation.config.ts',
+        'api/index.ts',
+        'api/effect-api.ts'
+    ])requiredFile(root, `${appPath}/${relative}`, `${appId} API surface`);
+}
+function validateWorkspace(root, expected) {
+    const readJson = (relative)=>record(JSON.parse(node_fs.readFileSync(safePath(root, relative, relative), 'utf8')), relative);
+    const topology = readJson('topology/reference-topology.json');
+    const ownership = readJson('topology/ownership.json');
+    const overlay = readJson('topology/local-overlays/development.json');
+    const rootManifest = readJson('package.json');
+    const workspace = record(yaml.load(node_fs.readFileSync(node_path.join(root, 'pnpm-workspace.yaml'), 'utf8')), 'pnpm-workspace.yaml');
+    for (const [label, value] of [
+        [
+            'topology',
+            topology
+        ],
+        [
+            'ownership',
+            ownership
+        ],
+        [
+            'overlay',
+            overlay
+        ]
+    ])assert(1 === value.schemaVersion, `${label} schemaVersion must be 1`);
+    assert(rootManifest.name === expected.packageScope, 'Root package name disagrees with the workspace scope');
+    const shell = record(topology.shell, 'topology.shell');
+    const verticals = entries(topology.verticals, 'topology.verticals');
+    const shells = [
+        shell,
+        ...entries(topology.shells ?? [], 'topology.shells')
+    ];
+    const apps = [
+        ...shells,
+        ...verticals
+    ];
+    const shared = entries(topology.sharedPackages ?? [], 'topology.sharedPackages');
+    const owners = entries(ownership.owners, 'ownership.owners');
+    distinct(apps.map((app)=>app.id), 'topology app ids');
+    distinct([
+        ...apps,
+        ...shared
+    ].map((app)=>app.path), 'topology package paths');
+    distinct(shared.map((pkg)=>pkg.id), 'topology shared package ids');
+    distinct(owners.map((owner)=>owner.id), 'ownership ids');
+    assert(shared.length === expected.sharedPackages.length, 'Shared package membership disagrees with canonical inputs');
+    for (const expectedShared of expected.sharedPackages){
+        const actual = shared.find((entry)=>entry.id === expectedShared.id);
+        assert(actual?.path === expectedShared.path && actual?.package === expectedShared.packageName, `${expectedShared.id} shared package identity disagrees with canonical inputs`);
+    }
+    const expectedApps = new Map(expected.apps.map((app)=>[
+            app.id,
+            app
+        ]));
+    assert(apps.length === expectedApps.size, 'Topology app membership disagrees with canonical inputs');
+    const verticalIds = new Set(verticals.map((vertical)=>vertical.id));
+    const ids = new Set(apps.map((app)=>app.id));
+    for (const app of apps){
+        const input = expectedApps.get(app.id);
+        assert(input, `Unexpected topology app ${app.id}`);
+        assert(app.kind === input.kind, `${app.id} kind disagrees with canonical inputs`);
+        assert(app.path === input.path, `${app.id} path disagrees with canonical inputs`);
+        assert(app.package === input.packageName, `${app.id} package identity disagrees with canonical inputs`);
+        const manifest = readJson(`${app.path}/package.json`);
+        assert(manifest.name === app.package, `${app.id} package name contradicts topology`);
+        assert(manifest.modernjs?.appId === app.id, `${app.id} modernjs.appId contradicts topology`);
+        const owner = owners.find((candidate)=>candidate.id === app.id);
+        assert(owner?.path === app.path && owner?.package === manifest.name, `${app.id} ownership identity contradicts topology and package.json`);
+        const refs = app.moduleFederation?.verticalRefs ?? app.verticalRefs ?? [];
+        assert(Array.isArray(refs), `${app.id} verticalRefs must be an array`);
+        distinct(refs, `${app.id} verticalRefs`);
+        for (const ref of refs)assert(verticalIds.has(ref), `${app.id} references unknown vertical ${ref}`);
+        assert(JSON.stringify(refs) === JSON.stringify(input.verticalRefs), `${app.id} verticalRefs disagree with canonical inputs`);
+        const port = overlay.ports?.[app.id];
+        assert(Number.isInteger(port) && port > 0 && port < 65536, `${app.id} has no development port`);
+        requiredFile(root, `${app.path}/modern.config.ts`, `${app.id} Modern.js config`);
+        if (input.emitsUi) requiredFile(root, `${app.path}/src/modern.runtime.ts`, `${app.id} runtime`);
+        requiredFile(root, `${app.path}/shared/ultramodern-build.json`, `${app.id} build stamp`);
+        const cloudflare = record(app.cloudflare, `${app.id} cloudflare`);
+        for (const field of [
+            'workerName',
+            'publicUrlEnv'
+        ])assert('string' == typeof cloudflare[field] && cloudflare[field].length > 0, `${app.id} cloudflare.${field} is required`);
+        const cloudflareRoutes = record(cloudflare.routes, `${app.id} cloudflare.routes`);
+        record(cloudflare.security, `${app.id} cloudflare.security`);
+        record(cloudflare.qualityGates, `${app.id} cloudflare.qualityGates`);
+        if ('shell' === app.kind) assert('string' == typeof cloudflareRoutes.ssr && cloudflareRoutes.ssr.startsWith('/'), `${app.id} cloudflare SSR route is required`);
+        if (input.emitsApi) {
+            const routeKey = app.api?.protocol === 'rpc' ? 'rpc' : 'apiReadiness';
+            assert('string' == typeof cloudflareRoutes[routeKey] && cloudflareRoutes[routeKey].startsWith('/'), `${app.id} cloudflare API ${routeKey} route is required`);
+        }
+        if (input.emitsUi && 'shell' !== app.kind) {
+            assert('string' == typeof overlay.manifests?.[app.id], `${app.id} has no development MF manifest URL`);
+            developmentUrl(overlay.manifests[app.id], port, `${app.id} MF manifest URL`, '/mf-manifest.json');
+            requiredFile(root, `${app.path}/module-federation.config.ts`, `${app.id} Module Federation config`);
+            for (const [expose, relative] of Object.entries(input.exposes)){
+                assert('string' == typeof relative && relative.startsWith('./src/'), `${app.id} ${expose} Module Federation expose must target a source file`);
+                assert(node_fs.existsSync(node_path.join(root, app.path, relative)), `${app.id} ${expose} Module Federation expose source ${relative} is missing`);
+            }
+        }
+        if (input.emitsApi) assert('string' == typeof overlay.apis?.[app.id], `${app.id} has no development API URL`);
+        if (input.emitsApi && 'vertical' === app.kind) {
+            const apiUrl = developmentUrl(overlay.apis[app.id], port, `${app.id} API URL`);
+            const serverExecution = record(overlay.serverExecution?.[app.id], `${app.id} server execution`);
+            assert(serverExecution.apiBaseUrl === apiUrl.href.replace(/\/$/, ''), `${app.id} server execution API URL disagrees with overlay`);
+            const backend = record(app.backendFederation, `${app.id} backendFederation`);
+            const node = record(backend.executionSurfaces?.node, `${app.id} backendFederation node`);
+            developmentUrl(node.manifestUrl, port, `${app.id} backend manifest URL`, '/backend-mf-manifest.json');
+            developmentUrl(node.containerEntry, port, `${app.id} backend container URL`, '/backendRemoteEntry.cjs');
+            validateBackendFederationEntrypoints(root, app.path, app.id);
+            const apiExport = manifest.exports?.['./api'];
+            assert('string' == typeof apiExport && apiExport.startsWith('./shared/'), `${app.id} must export its shared API contract`);
+            assert(node_fs.existsSync(node_path.join(root, app.path, apiExport)), `${app.id} shared API contract ${apiExport} is missing`);
+            validateApiClientExports(root, app.path, app.id, manifest.exports);
+            const backendDelivery = record(backend.deliveryUnit, `${app.id} backendFederation.deliveryUnit`);
+            assert(backendDelivery.unitId === app.deliveryUnit?.unitId && backendDelivery.packageName === manifest.name && backendDelivery.buildMarker === app.deliveryUnit?.buildMarker, `${app.id} backend federation delivery identity contradicts topology`);
+            assert(backend.versionBoundary?.identityRoot === 'deliveryUnit' && backend.versionBoundary?.packageName === manifest.name, `${app.id} backend federation version boundary contradicts topology`);
+            assert(node.expected?.unitId === app.deliveryUnit?.unitId && node.expected?.buildMarker === app.deliveryUnit?.buildMarker, `${app.id} backend federation node identity contradicts topology`);
+            assert(serverExecution.deliveryUnit?.unitId === app.deliveryUnit?.unitId && serverExecution.deliveryUnit?.buildMarker === app.deliveryUnit?.buildMarker, `${app.id} server execution identity contradicts topology`);
+            assert(serverExecution.node?.manifestUrl === node.manifestUrl && serverExecution.node?.containerEntry === node.containerEntry, `${app.id} server execution node endpoints contradict topology`);
+        }
+        if ('vertical' === app.kind && !input.emitsUi) validateApiOnlySourceSurface(root, app);
+        if ('vertical' === app.kind && !input.emitsApi) {
+            assert(!Object.hasOwn(overlay.apis ?? {}, app.id) && !Object.hasOwn(overlay.serverExecution ?? {}, app.id), `${app.id} UI-only vertical must not declare API endpoints`);
+            assert(!app.backendFederation && !app.api, `${app.id} UI-only vertical must not declare a backend API`);
+            for (const relative of [
+                'shared/api.ts',
+                'shared/rpc.ts',
+                'backend-federation.config.ts',
+                'api/index.ts',
+                'api/effect-api.ts',
+                'api/backend-federation.ts',
+                `src/api/${app.id}-client.ts`,
+                `src/api/${app.id}-rpc-client.ts`
+            ])assert(!node_fs.existsSync(node_path.join(root, app.path, relative)), `Unexpected ${app.path}/${relative} for a ui-only unit`);
+        }
+        const delivery = record(app.deliveryUnit, `${app.id} deliveryUnit`);
+        assert('string' == typeof delivery.unitId && delivery.unitId.length > 0 && delivery.packageName === manifest.name, `${app.id} delivery unit identity contradicts package.json`);
+        const build = readJson(`${app.path}/shared/ultramodern-build.json`);
+        assert(build.deliveryUnit?.unitId === delivery.unitId && build.deliveryUnit?.packageName === manifest.name && build.deliveryUnit?.buildMarker === delivery.buildMarker, `${app.id} build identity contradicts topology`);
+    }
+    for (const pkg of shared){
+        const manifest = readJson(`${pkg.path}/package.json`);
+        assert(manifest.name === pkg.package, `${pkg.id} shared package identity contradicts topology`);
+        assert(owners.some((owner)=>owner.id === pkg.id && owner.path === pkg.path && owner.package === manifest.name), `${pkg.id} ownership identity contradicts package.json`);
+    }
+    for (const owner of owners)assert(ids.has(owner.id) || shared.some((pkg)=>pkg.id === owner.id), `Ownership names unknown package ${owner.id}`);
+    const catalogs = record(workspace.catalogs ?? {}, 'workspace catalogs');
+    const catalog = record(catalogs.ultramodern ?? {}, 'ultramodern catalog');
+    const producer = hasCreateReleaseCohort() ? readCreateReleaseCohort() : void 0;
+    const sourceCheckout = isCreatePackageSourceCheckout();
+    const cohort = new Map(producer?.packages.map((pkg)=>[
+            pkg.sourceName,
+            pkg
+        ]) ?? []);
+    const members = [
+        ...apps,
+        ...shared
+    ].map((app)=>`${app.path}/package.json`);
+    members.push('package.json');
+    for (const member of members){
+        const manifest = readJson(member);
+        for (const group of [
+            'dependencies',
+            'devDependencies',
+            'optionalDependencies',
+            'peerDependencies'
+        ])for (const [name, request] of Object.entries(record(manifest[group] ?? {}, `${member} ${group}`))){
+            if (!expected.modernPackages.includes(name)) continue;
+            assert('string' == typeof request, `${member} ${name} dependency request must be a string`);
+            const catalogRequest = 'catalog:ultramodern' === request ? catalog[name] : void 0;
+            const effective = catalogRequest ?? request;
+            assert('string' == typeof effective && effective.length > 0, `${member} ${name} has no catalog entry`);
+            if ('workspace:*' !== request) assert('catalog:ultramodern' === request, `${member} ${name} must use the ultramodern catalog`);
+            assert(producer || sourceCheckout || 'workspace:*' === request, `${member} ${name} uses the ultramodern catalog, but the installed ultramodern-create package is missing release-cohort.json. Install a published ultramodern-create release, or generate with --ultramodern-package-source workspace.`);
+            if (producer && 'workspace:*' !== request) {
+                const release = cohort.get(name);
+                assert(release, `${member} ${name} is absent from the installed release cohort`);
+                assert(effective === `npm:${release.targetName}@${release.version}`, `${member} ${name} catalog request disagrees with the installed release cohort`);
+            }
+            let memberDir = node_path.dirname(node_path.join(root, member));
+            let installedPath;
+            while(memberDir.startsWith(node_path.resolve(root))){
+                const candidate = node_path.join(memberDir, 'node_modules', name, 'package.json');
+                if (node_fs.existsSync(candidate)) {
+                    installedPath = candidate;
+                    break;
+                }
+                if (memberDir === node_path.resolve(root)) break;
+                memberDir = node_path.dirname(memberDir);
+            }
+            if ('workspace:*' !== request && node_fs.existsSync(node_path.join(root, 'node_modules'))) assert(installedPath, `${member} ${name} is not installed`);
+            if (installedPath && 'workspace:*' !== request) {
+                const installed = record(JSON.parse(node_fs.readFileSync(installedPath, 'utf8')), installedPath);
+                const aliasMatch = /^npm:(@[^/]+\/[^@]+)@(.+)$/u.exec(effective);
+                assert(aliasMatch, `${member} ${name} catalog entry must name an installed package and version`);
+                assert(installed.name === aliasMatch[1] && installed.version === aliasMatch[2], `${member} ${name} installed package identity/version disagrees with the catalog`);
+                if (producer) assert(installed.version === producer.release.version, `${member} ${name} installed version disagrees with the release cohort`);
+            }
+        }
+    }
+    assertCompilerArchitecture(root, expected);
+    console.log('UltraModern workspace validated');
+}
+export { validateApiClientExports, validateApiOnlySourceSurface, validateBackendFederationEntrypoints, validateWorkspace };

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

@@ -1,39 +1,84 @@
 import "node:module";
-const TANSTACK_ROUTER_VERSION = '1.170.33';
-const TANSTACK_ROUTER_CORE_VERSION = '1.171.28';
-const TANSTACK_HISTORY_VERSION = '1.162.2';
-const MODULE_FEDERATION_VERSION = '2.9.0';
-const ZEPHYR_RSPACK_PLUGIN_VERSION = '1.2.4';
-const ZEPHYR_AGENT_VERSION = '1.2.4';
-const WRANGLER_VERSION = '4.116.0';
+const TANSTACK_ROUTER_VERSION = '1.170.39';
+const TANSTACK_ROUTER_CORE_VERSION = '1.171.32';
+const TANSTACK_HISTORY_VERSION = '1.162.4';
+const MODULE_FEDERATION_VERSION = '2.9.2';
+const MODULE_FEDERATION_MODERN_JS_V3_FORK_VERSION = '2.9.3';
+const ZEPHYR_RSPACK_PLUGIN_VERSION = '1.4.0';
+const ZEPHYR_AGENT_VERSION = '1.4.0';
+const WRANGLER_VERSION = '4.137.0';
 const CLOUDFLARE_COMPATIBILITY_DATE = '2026-06-02';
 const TAILWIND_VERSION = '4.3.3';
 const RSBUILD_PLUGIN_TAILWINDCSS_VERSION = '2.0.3';
-const EFFECT_VERSION = '4.0.0-rc.112';
-const EFFECT_VITEST_VERSION = '4.0.0-rc.112';
-const EFFECT_TSGO_VERSION = '0.41.0';
-const MSGPACKR_VERSION = '2.1.0';
-const ZOD_VERSION = '4.5.4';
-const DRIZZLE_ORM_VERSION = '1.0.0-rc.4';
+const EFFECT_VERSION = '4.0.0-rc.117';
+const EFFECT_TSGO_VERSION = '0.45.0';
 const TYPESCRIPT_STABLE_VERSION = '7.0.2';
 const TYPESCRIPT_VERSION = TYPESCRIPT_STABLE_VERSION;
 const TYPESCRIPT_NATIVE_PREVIEW_VERSION = '7.0.0-dev.20260707.2';
-const OXLINT_VERSION = '1.81.0';
-const OXFMT_VERSION = '0.66.0';
-const ULTRACITE_VERSION = '7.11.0';
-const CROSS_ENV_VERSION = '10.1.0';
-const LEFTHOOK_VERSION = '^2.1.10';
+const OXLINT_VERSION = '1.85.0';
+const OXFMT_VERSION = '0.70.0';
+const ULTRACITE_VERSION = '7.12.0';
+const LEFTHOOK_VERSION = '^2.1.14';
 const I18NEXT_VERSION = '26.4.2';
-const MODULE_FEDERATION_NODE_VERSION = '2.7.50';
-const MINIFLARE_VERSION = '4.20260730.0';
-const WORKERD_VERSION = '1.20260730.1';
-const CLOUDFLARE_WORKERS_TYPES_VERSION = '5.20260906.1';
+const MODULE_FEDERATION_NODE_VERSION = '2.7.52';
+const MINIFLARE_VERSION = '5.20260921.0-alpha';
+const WORKERD_VERSION = '1.20260921.1';
+const CLOUDFLARE_WORKERS_TYPES_VERSION = '5.20260923.1';
 const NODE_FETCH_VERSION = '^3.3.2';
-const REACT_VERSION = '19.2.8';
-const REACT_DOM_VERSION = '19.2.8';
-const TYPES_NODE_VERSION = '^26.4.1';
-const TYPES_REACT_VERSION = '^19.2.18';
-const TYPES_REACT_DOM_VERSION = '^19.2.7';
+const REACT_VERSION = '19.3.0';
+const REACT_DOM_VERSION = '19.3.0';
+const TYPES_NODE_VERSION = '^26.6.2';
+const TYPES_REACT_VERSION = '^19.3.0';
+const TYPES_REACT_DOM_VERSION = '^19.3.0';
 const NODE_VERSION = '26.7.0';
-const PNPM_VERSION = '11.24.0';
-export { CLOUDFLARE_COMPATIBILITY_DATE, CLOUDFLARE_WORKERS_TYPES_VERSION, CROSS_ENV_VERSION, DRIZZLE_ORM_VERSION, EFFECT_TSGO_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, I18NEXT_VERSION, LEFTHOOK_VERSION, MINIFLARE_VERSION, MODULE_FEDERATION_NODE_VERSION, MODULE_FEDERATION_VERSION, MSGPACKR_VERSION, NODE_FETCH_VERSION, NODE_VERSION, OXFMT_VERSION, OXLINT_VERSION, PNPM_VERSION, REACT_DOM_VERSION, REACT_VERSION, RSBUILD_PLUGIN_TAILWINDCSS_VERSION, TAILWIND_VERSION, TANSTACK_HISTORY_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, TYPESCRIPT_STABLE_VERSION, TYPESCRIPT_VERSION, TYPES_NODE_VERSION, TYPES_REACT_DOM_VERSION, TYPES_REACT_VERSION, ULTRACITE_VERSION, WORKERD_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION, ZOD_VERSION };
+const PNPM_VERSION = '11.27.1';
+const ULTRAMODERN_PACKAGE_PINS = {
+    appDependencies: {
+        '@module-federation/bridge-react': `npm:@bleedingdev/mf-bridge-react@${MODULE_FEDERATION_VERSION}`,
+        '@module-federation/modern-js-v3': `npm:@bleedingdev/mf-modern-js-v3@${MODULE_FEDERATION_MODERN_JS_V3_FORK_VERSION}`,
+        '@module-federation/runtime': `npm:@bleedingdev/mf-runtime@${MODULE_FEDERATION_VERSION}`,
+        '@tanstack/react-router': TANSTACK_ROUTER_VERSION,
+        i18next: I18NEXT_VERSION,
+        'node-fetch': NODE_FETCH_VERSION,
+        react: REACT_VERSION,
+        'react-dom': REACT_DOM_VERSION
+    },
+    bffEffectDependencies: {
+        '@effect/opentelemetry': EFFECT_VERSION,
+        effect: EFFECT_VERSION
+    },
+    appDevDependencies: {
+        '@effect/tsgo': EFFECT_TSGO_VERSION,
+        '@rsbuild/plugin-tailwindcss': `^${RSBUILD_PLUGIN_TAILWINDCSS_VERSION}`,
+        "@typescript/native": `npm:typescript@${TYPESCRIPT_VERSION}`,
+        '@types/node': TYPES_NODE_VERSION,
+        '@types/react': TYPES_REACT_VERSION,
+        '@types/react-dom': TYPES_REACT_DOM_VERSION,
+        tailwindcss: `^${TAILWIND_VERSION}`,
+        typescript: TYPESCRIPT_VERSION,
+        wrangler: WRANGLER_VERSION,
+        'zephyr-rspack-plugin': ZEPHYR_RSPACK_PLUGIN_VERSION
+    },
+    rootDevDependencies: {
+        '@effect/tsgo': EFFECT_TSGO_VERSION,
+        "@typescript/native": `npm:typescript@${TYPESCRIPT_VERSION}`,
+        '@types/node': TYPES_NODE_VERSION,
+        lefthook: LEFTHOOK_VERSION,
+        miniflare: MINIFLARE_VERSION,
+        oxlint: OXLINT_VERSION,
+        oxfmt: OXFMT_VERSION,
+        ultracite: ULTRACITE_VERSION,
+        wrangler: WRANGLER_VERSION,
+        'zephyr-agent': ZEPHYR_AGENT_VERSION
+    },
+    transitiveDependencies: {
+        '@cloudflare/workers-types': CLOUDFLARE_WORKERS_TYPES_VERSION,
+        '@module-federation/node': MODULE_FEDERATION_NODE_VERSION,
+        '@tanstack/history': TANSTACK_HISTORY_VERSION,
+        '@tanstack/router-core': TANSTACK_ROUTER_CORE_VERSION,
+        "@typescript/native-preview": TYPESCRIPT_NATIVE_PREVIEW_VERSION,
+        miniflare: MINIFLARE_VERSION,
+        workerd: WORKERD_VERSION
+    }
+};
+export { CLOUDFLARE_COMPATIBILITY_DATE, CLOUDFLARE_WORKERS_TYPES_VERSION, EFFECT_TSGO_VERSION, EFFECT_VERSION, I18NEXT_VERSION, LEFTHOOK_VERSION, MINIFLARE_VERSION, MODULE_FEDERATION_MODERN_JS_V3_FORK_VERSION, MODULE_FEDERATION_NODE_VERSION, MODULE_FEDERATION_VERSION, NODE_FETCH_VERSION, NODE_VERSION, OXFMT_VERSION, OXLINT_VERSION, PNPM_VERSION, REACT_DOM_VERSION, REACT_VERSION, RSBUILD_PLUGIN_TAILWINDCSS_VERSION, TAILWIND_VERSION, TANSTACK_HISTORY_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, TYPESCRIPT_STABLE_VERSION, TYPESCRIPT_VERSION, TYPES_NODE_VERSION, TYPES_REACT_DOM_VERSION, TYPES_REACT_VERSION, ULTRACITE_VERSION, ULTRAMODERN_PACKAGE_PINS, WORKERD_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION };

package/dist/esm-node/ultramodern-workspace/workspace-artifact-ownership.js

@@ -0,0 +1,129 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { parse } from "@babel/parser";
+import { configuredDevelopmentPorts } from "./add-vertical/workspace-state.js";
+import { resolveRemoteRefs } from "./descriptors.js";
+import { formatGeneratedSourceCandidates, writeFileReplacing } from "./fs-io.js";
+import { createAppModernConfig } from "./module-federation.js";
+import { createRootTsConfig } from "./tsconfigs.js";
+import { createWorkspaceScriptArtifacts } from "./workspace-scripts.js";
+import { createZeropsYaml } from "./zerops.js";
+function workspaceArtifactCandidates(scope, apps, enableTailwind, alternateApps = []) {
+    return [
+        ...createWorkspaceScriptArtifacts(),
+        {
+            relativePath: 'tsconfig.json',
+            content: `${JSON.stringify(createRootTsConfig(apps), null, 2)}\n`
+        },
+        ...[
+            apps,
+            ...alternateApps.length ? [
+                alternateApps
+            ] : []
+        ].flatMap((projection)=>{
+            const verticals = projection.filter((app)=>'vertical' === app.kind);
+            const devPorts = workspaceDevelopmentPorts(projection);
+            return [
+                {
+                    relativePath: 'zerops.yaml',
+                    content: `${createZeropsYaml(scope, projection)}\n`
+                },
+                ...projection.map((app)=>({
+                        relativePath: `${app.directory}/modern.config.ts`,
+                        content: createAppModernConfig(scope, app, 'shell' === app.kind ? resolveRemoteRefs(app, verticals) : verticals, enableTailwind, devPorts)
+                    }))
+            ];
+        })
+    ];
+}
+function workspaceDevelopmentPorts(apps, ports = {}) {
+    return apps.filter((app)=>'shell' === app.kind).length > 1 ? configuredDevelopmentPorts({
+        ...ports,
+        ...Object.fromEntries(apps.map((app)=>[
+                app.id,
+                app.port
+            ]))
+    }).toSorted((left, right)=>left - right) : void 0;
+}
+function isLiteralData(node, literalIdentifiers) {
+    if (!node) return false;
+    if ('Identifier' === node.type) return literalIdentifiers?.has(node.name) ?? false;
+    if ([
+        'StringLiteral',
+        'NumericLiteral',
+        'BooleanLiteral',
+        'NullLiteral'
+    ].includes(node.type)) return true;
+    if ('UnaryExpression' === node.type) return '-' === node.operator && 'NumericLiteral' === node.argument.type;
+    if ('ArrayExpression' === node.type) return node.elements.every((element)=>isLiteralData(element, literalIdentifiers));
+    return 'ObjectExpression' === node.type && node.properties.every((property)=>'ObjectProperty' === property.type && !property.computed && !property.shorthand && [
+            'Identifier',
+            'StringLiteral',
+            'NumericLiteral'
+        ].includes(property.key.type) && isLiteralData(property.value, literalIdentifiers));
+}
+function withoutGeneratedData(source, binding) {
+    if (!binding) return source;
+    const parsed = parse(source, {
+        sourceType: 'module',
+        plugins: [
+            "typescript"
+        ]
+    });
+    for (const statement of parsed.program.body)if ('VariableDeclaration' === statement.type && 'const' === statement.kind) {
+        for (const declaration of statement.declarations)if ('Identifier' === declaration.id.type && declaration.id.name === binding && declaration.init && isLiteralData(declaration.init)) return source.slice(0, declaration.init.start) + '{}' + source.slice(declaration.init.end);
+    }
+    return source;
+}
+function preserveConsumerWorkspaceArtifacts(workspaceRoot, candidates) {
+    const preservedPaths = new Set();
+    const recognizedPaths = new Map();
+    const physicalRoot = node_fs.realpathSync(workspaceRoot);
+    const canonicalSources = formatGeneratedSourceCandidates(candidates.map((candidate, index)=>[
+            `canonical/${index}/${candidate.relativePath}`,
+            withoutGeneratedData(candidate.content, candidate.generatedDataBinding)
+        ]));
+    for (const [index, candidate] of candidates.entries()){
+        const relativePath = candidate.relativePath;
+        const filePath = node_path.join(workspaceRoot, relativePath);
+        if (!node_fs.existsSync(filePath)) continue;
+        const physicalRelative = node_path.relative(physicalRoot, node_fs.realpathSync(filePath));
+        if ('..' === physicalRelative || physicalRelative.startsWith(`..${node_path.sep}`) || node_path.isAbsolute(physicalRelative)) throw new Error(`Refusing to inspect an artifact outside the workspace: ${relativePath}`);
+        const source = node_fs.readFileSync(filePath, 'utf8');
+        let recognized = source === candidate.content;
+        if (!recognized) try {
+            const normalized = withoutGeneratedData(source, candidate.generatedDataBinding);
+            const canonical = canonicalSources[index];
+            recognized = normalized === canonical || formatGeneratedSourceCandidates([
+                [
+                    relativePath,
+                    normalized
+                ]
+            ])[0] === canonical;
+        } catch  {}
+        recognizedPaths.set(relativePath, true === recognizedPaths.get(relativePath) || recognized);
+    }
+    for (const [relativePath, recognized] of recognizedPaths)if (!recognized) preservedPaths.add(relativePath);
+    const reported = new Set();
+    const isPreserved = (filePath)=>{
+        const relativePath = node_path.relative(workspaceRoot, filePath).split(node_path.sep).join('/');
+        if (!preservedPaths.has(relativePath)) return false;
+        if (!reported.has(relativePath)) {
+            console.warn(`${relativePath} preserved consumer-owned artifact: its canonical generated source does not match.`);
+            reported.add(relativePath);
+        }
+        return true;
+    };
+    return {
+        preservedPaths,
+        io: {
+            write: (filePath, content)=>{
+                if (isPreserved(filePath)) return false;
+                writeFileReplacing(workspaceRoot, node_path.relative(workspaceRoot, filePath), content);
+                return true;
+            }
+        }
+    };
+}
+export { preserveConsumerWorkspaceArtifacts, workspaceArtifactCandidates, workspaceDevelopmentPorts };