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

package/dist/esm-node/ultramodern-workspace/overlay-baseline-guard.js

@@ -0,0 +1,351 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { yaml } from "@modern-js/utils";
+import { isRecord } from "./types.js";
+import { EFFECT_VERSION, REACT_DOM_VERSION, REACT_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION } from "./versions.js";
+const BASELINE_DEPENDENCY_PINS = Object.freeze({
+    react: REACT_VERSION,
+    'react-dom': REACT_DOM_VERSION,
+    '@tanstack/react-router': TANSTACK_ROUTER_VERSION,
+    '@tanstack/router-core': TANSTACK_ROUTER_CORE_VERSION,
+    effect: EFFECT_VERSION,
+    tailwindcss: TAILWIND_VERSION
+});
+const FORBIDDEN_SHELL_ARTIFACT_SEGMENTS = [
+    'api',
+    'server',
+    'backend-federation.config.ts'
+];
+const IGNORED_WALK_DIRECTORIES = new Set([
+    '.git',
+    '.nx',
+    '.output',
+    'coverage',
+    'dist',
+    'dist-cloudflare',
+    'node_modules'
+]);
+class OverlayBaselineRelaxationError extends Error {
+    constructor(generator, violations){
+        super([
+            `UltraModern CodeSmith overlay relaxed the Platform Baseline: ${generator}`,
+            ...violations.map((violation)=>`  - ${violation.path}: ${violation.detail}`)
+        ].join('\n')), this.code = 'ULTRAMODERN_OVERLAY_BASELINE_RELAXATION';
+        this.name = 'OverlayBaselineRelaxationError';
+        this.generator = generator;
+        this.violations = violations;
+    }
+}
+function walkFiles(root, predicate) {
+    const matches = [];
+    const queue = [
+        root
+    ];
+    while(queue.length > 0){
+        const current = queue.shift();
+        let entries;
+        try {
+            entries = node_fs.readdirSync(current, {
+                withFileTypes: true
+            });
+        } catch  {
+            continue;
+        }
+        for (const entry of entries){
+            const absolute = node_path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (!IGNORED_WALK_DIRECTORIES.has(entry.name)) queue.push(absolute);
+                continue;
+            }
+            const relative = node_path.relative(root, absolute).split(node_path.sep).join('/');
+            if (predicate(relative)) matches.push(relative);
+        }
+    }
+    return matches.sort();
+}
+function isPackageManifest(relativePath) {
+    return 'package.json' === relativePath || relativePath.endsWith('/package.json');
+}
+const DEPENDENCY_SECTIONS = [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies'
+];
+function readPackageJson(workspaceRoot, packageJsonRelativePath) {
+    const parsed = JSON.parse(node_fs.readFileSync(node_path.join(workspaceRoot, packageJsonRelativePath), 'utf-8'));
+    return isRecord(parsed) ? parsed : {};
+}
+function dependencyEntries(parsed) {
+    const entries = [];
+    for (const section of DEPENDENCY_SECTIONS){
+        const group = parsed[section];
+        if (isRecord(group)) {
+            for (const [name, value] of Object.entries(group))if ('string' == typeof value) entries.push({
+                section,
+                name,
+                value
+            });
+        }
+    }
+    return entries;
+}
+function baselineDependencyFromKey(key) {
+    const candidate = key.trim().split('>').at(-1) ?? '';
+    return Object.keys(BASELINE_DEPENDENCY_PINS).find((dependency)=>candidate === dependency || candidate.startsWith(`${dependency}@`));
+}
+function collectPolicyEntries(value, prefix, entries) {
+    if (!isRecord(value)) return;
+    for (const [key, child] of Object.entries(value)){
+        const childPath = '' === prefix ? key : `${prefix}.${key}`;
+        const dependency = baselineDependencyFromKey(key);
+        if (void 0 !== dependency && 'string' == typeof child) entries.push({
+            path: childPath,
+            dependency,
+            value: child
+        });
+        if (isRecord(child)) collectPolicyEntries(child, childPath, entries);
+    }
+}
+function policyRoots(parsed) {
+    const pnpm = isRecord(parsed.pnpm) ? parsed.pnpm : void 0;
+    return [
+        [
+            'overrides',
+            parsed.overrides
+        ],
+        [
+            'resolutions',
+            parsed.resolutions
+        ],
+        [
+            'pnpm.overrides',
+            pnpm?.overrides
+        ],
+        [
+            'catalog',
+            parsed.catalog
+        ],
+        [
+            'catalogs',
+            parsed.catalogs
+        ],
+        [
+            'pnpm.catalog',
+            pnpm?.catalog
+        ],
+        [
+            'pnpm.catalogs',
+            pnpm?.catalogs
+        ]
+    ];
+}
+function baselinePolicyEntries(parsed) {
+    const entries = [];
+    for (const [prefix, value] of policyRoots(parsed))if (void 0 !== value) collectPolicyEntries(value, prefix, entries);
+    return entries;
+}
+function readPnpmWorkspaceYaml(workspaceRoot) {
+    try {
+        const parsed = yaml.load(node_fs.readFileSync(node_path.join(workspaceRoot, 'pnpm-workspace.yaml'), 'utf-8'));
+        return isRecord(parsed) ? parsed : {};
+    } catch  {
+        return {};
+    }
+}
+function collectCatalogValues(parsed) {
+    const values = new Map();
+    const collect = (value, prefix)=>{
+        if (!isRecord(value)) return;
+        for (const [key, child] of Object.entries(value)){
+            const childPath = '' === prefix ? key : `${prefix}.${key}`;
+            if ('string' == typeof child) {
+                values.set(key, child);
+                values.set(childPath, child);
+            } else collect(child, childPath);
+        }
+    };
+    for (const [prefix, value] of policyRoots(parsed).filter(([prefix])=>/catalog/u.test(prefix)))collect(value ?? {}, prefix);
+    return values;
+}
+function resolveCatalogReference(value, catalogValues) {
+    if (!value.startsWith('catalog:')) return value;
+    return catalogValues.get(value.slice(8)) ?? value;
+}
+function parseNpmAlias(value) {
+    if (!value.startsWith('npm:')) return;
+    const target = value.slice(4);
+    const separator = target.startsWith('@') ? target.indexOf('@', 1) : target.indexOf('@');
+    if (-1 === separator) return {
+        name: target,
+        range: void 0
+    };
+    return {
+        name: target.slice(0, separator),
+        range: target.slice(separator + 1)
+    };
+}
+function baselineSpecMatches(value, dependency) {
+    const expected = BASELINE_DEPENDENCY_PINS[dependency];
+    if (value === expected) return true;
+    const alias = parseNpmAlias(value);
+    return alias?.name === dependency && alias.range === expected;
+}
+function baselinePinsFromParsed(parsed) {
+    const pins = {};
+    for (const section of DEPENDENCY_SECTIONS){
+        const group = parsed[section];
+        if (isRecord(group)) for (const dependency of Object.keys(BASELINE_DEPENDENCY_PINS)){
+            const value = group[dependency];
+            if ('string' == typeof value) pins[`${section}.${dependency}`] = value;
+        }
+    }
+    return pins;
+}
+function readBaselinePins(workspaceRoot, packageJsonRelativePath) {
+    return baselinePinsFromParsed(readPackageJson(workspaceRoot, packageJsonRelativePath));
+}
+function captureOverlayBaselineSnapshot(workspaceRoot, shellPackageDirectories) {
+    const baselinePinsByManifest = {};
+    const baselinePolicyPinsByManifest = {};
+    for (const manifest of walkFiles(workspaceRoot, isPackageManifest)){
+        const parsed = readPackageJson(workspaceRoot, manifest);
+        baselinePinsByManifest[manifest] = readBaselinePins(workspaceRoot, manifest);
+        baselinePolicyPinsByManifest[manifest] = Object.fromEntries(baselinePolicyEntries(parsed).map((entry)=>[
+                entry.path,
+                entry.value
+            ]));
+    }
+    const shellFiles = new Set();
+    for (const shellDir of shellPackageDirectories){
+        const absolute = node_path.join(workspaceRoot, shellDir);
+        if (node_fs.existsSync(absolute)) for (const file of walkFiles(absolute, ()=>true))shellFiles.add(`${shellDir}/${file}`);
+    }
+    return {
+        baselinePinsByManifest,
+        baselinePolicyPinsByManifest,
+        baselineWorkspacePolicyPins: Object.fromEntries(baselinePolicyEntries(readPnpmWorkspaceYaml(workspaceRoot)).map((entry)=>[
+                entry.path,
+                entry.value
+            ])),
+        shellPackageDirectories,
+        shellFiles
+    };
+}
+function collectPolicyViolations(parsed, beforePolicyPins, displayPath) {
+    const violations = [];
+    const currentPolicyEntries = baselinePolicyEntries(parsed);
+    const currentPolicyPins = Object.fromEntries(currentPolicyEntries.map((entry)=>[
+            entry.path,
+            entry.value
+        ]));
+    for (const [policyPath, previous] of Object.entries(beforePolicyPins)){
+        if (Object.hasOwn(currentPolicyPins, policyPath)) continue;
+        const dependency = baselineDependencyFromKey(policyPath.split('.').at(-1) ?? '') ?? policyPath.split('.').at(-1) ?? policyPath;
+        const expected = BASELINE_DEPENDENCY_PINS[dependency];
+        if (void 0 !== expected) violations.push({
+            kind: 'baseline-version-relaxation',
+            path: `${displayPath}#${policyPath}`,
+            detail: `overlay removed baseline policy "${policyPath}" from "${previous}"; Platform Baseline pin is "${expected}"`
+        });
+    }
+    const catalogValues = collectCatalogValues(parsed);
+    for (const entry of currentPolicyEntries){
+        const resolvedVersion = resolveCatalogReference(entry.value, catalogValues);
+        const expected = BASELINE_DEPENDENCY_PINS[entry.dependency];
+        if (!baselineSpecMatches(resolvedVersion, entry.dependency)) violations.push({
+            kind: 'baseline-version-relaxation',
+            path: `${displayPath}#${entry.path}`,
+            detail: `overlay policy "${entry.path}" pins baseline dependency "${entry.dependency}" at "${entry.value}"; Platform Baseline pin is "${expected}"`
+        });
+    }
+    return violations;
+}
+function collectVersionViolations(workspaceRoot, snapshot) {
+    const violations = [];
+    const manifests = new Set([
+        ...walkFiles(workspaceRoot, isPackageManifest),
+        ...Object.keys(snapshot.baselinePinsByManifest)
+    ]);
+    for (const manifest of manifests){
+        let parsed;
+        try {
+            parsed = readPackageJson(workspaceRoot, manifest);
+        } catch  {
+            parsed = {};
+        }
+        const pins = baselinePinsFromParsed(parsed);
+        const before = snapshot.baselinePinsByManifest[manifest] ?? {};
+        for (const key of Object.keys(before)){
+            if (Object.hasOwn(pins, key)) continue;
+            const separator = key.indexOf('.');
+            const section = key.slice(0, separator);
+            const dependency = key.slice(separator + 1);
+            const expected = BASELINE_DEPENDENCY_PINS[dependency];
+            violations.push({
+                kind: 'baseline-version-relaxation',
+                path: manifest,
+                detail: `overlay removed baseline dependency "${dependency}" from ${section}; Platform Baseline pin is "${expected}"`
+            });
+        }
+        const catalogValues = collectCatalogValues(parsed);
+        for (const [key, version] of Object.entries(pins)){
+            const dependency = key.slice(key.indexOf('.') + 1);
+            const expected = BASELINE_DEPENDENCY_PINS[dependency];
+            const previous = before[key];
+            const resolvedVersion = resolveCatalogReference(version, catalogValues);
+            const matches = baselineSpecMatches(resolvedVersion, dependency);
+            if (void 0 !== previous || matches) {
+                if (void 0 !== previous && version !== previous && !matches) violations.push({
+                    kind: 'baseline-version-relaxation',
+                    path: manifest,
+                    detail: `overlay changed baseline dependency "${dependency}" from "${previous}" to "${version}"; Platform Baseline pin is "${expected}"`
+                });
+            } else violations.push({
+                kind: 'baseline-version-relaxation',
+                path: manifest,
+                detail: `overlay added baseline dependency "${dependency}" at "${version}"; Platform Baseline pin is "${expected}"`
+            });
+        }
+        for (const entry of dependencyEntries(parsed)){
+            const alias = parseNpmAlias(entry.value);
+            if (void 0 === alias) continue;
+            const expected = BASELINE_DEPENDENCY_PINS[alias.name];
+            if (void 0 !== expected && alias.range !== expected) violations.push({
+                kind: 'baseline-version-relaxation',
+                path: manifest,
+                detail: `overlay alias "${entry.name}" resolves to baseline dependency "${alias.name}" at "${entry.value}"; Platform Baseline pin is "${expected}"`
+            });
+        }
+        violations.push(...collectPolicyViolations(parsed, snapshot.baselinePolicyPinsByManifest?.[manifest] ?? {}, manifest));
+    }
+    violations.push(...collectPolicyViolations(readPnpmWorkspaceYaml(workspaceRoot), snapshot.baselineWorkspacePolicyPins ?? {}, 'pnpm-workspace.yaml'));
+    return violations;
+}
+function collectForbiddenShellArtifactViolations(workspaceRoot, snapshot) {
+    const violations = [];
+    for (const shellDir of snapshot.shellPackageDirectories){
+        const absolute = node_path.join(workspaceRoot, shellDir);
+        if (node_fs.existsSync(absolute)) for (const file of walkFiles(absolute, ()=>true)){
+            const relative = `${shellDir}/${file}`;
+            if (snapshot.shellFiles.has(relative)) continue;
+            const segments = file.split('/');
+            const forbidden = FORBIDDEN_SHELL_ARTIFACT_SEGMENTS.find((segment)=>segments.includes(segment) || file === segment);
+            if (forbidden) violations.push({
+                kind: 'forbidden-shell-artifact',
+                path: relative,
+                detail: `overlay introduced a forbidden thin-shell artifact class "${forbidden}" into shell package ${shellDir}`
+            });
+        }
+    }
+    return violations;
+}
+function assertOverlayPreservedBaseline(options) {
+    const violations = [
+        ...collectVersionViolations(options.workspaceRoot, options.snapshot),
+        ...collectForbiddenShellArtifactViolations(options.workspaceRoot, options.snapshot)
+    ];
+    if (violations.length > 0) throw new OverlayBaselineRelaxationError(options.generator, violations);
+}
+export { BASELINE_DEPENDENCY_PINS, OverlayBaselineRelaxationError, assertOverlayPreservedBaseline, captureOverlayBaselineSnapshot };

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

@@ -0,0 +1,104 @@
+import "node:module";
+import { spawnSync } from "node:child_process";
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { assertOverlayPreservedBaseline, captureOverlayBaselineSnapshot } from "./overlay-baseline-guard.js";
+const overlays_require = createRequire(import.meta.url);
+function resolveShellPackageDirectories(workspaceRoot) {
+    const appsRoot = node_path.join(workspaceRoot, 'apps');
+    let entries;
+    try {
+        entries = node_fs.readdirSync(appsRoot, {
+            withFileTypes: true
+        });
+    } catch  {
+        return [];
+    }
+    return entries.filter((entry)=>entry.isDirectory()).map((entry)=>`apps/${entry.name}`).sort();
+}
+const overlayRunnerSource = `
+const fs = require('node:fs');
+
+(async () => {
+  const payload = JSON.parse(fs.readFileSync(0, 'utf-8'));
+  const { CodeSmith } = require(payload.codesmithModulePath);
+  const codesmith = new CodeSmith({});
+  await codesmith.forge({
+    pwd: payload.workspaceRoot,
+    tasks: [
+      {
+        generator: payload.generator,
+        config: payload.config,
+      },
+    ],
+  });
+})().catch(error => {
+  console.error(error?.stack || error?.message || String(error));
+  process.exit(1);
+});
+`;
+function runCodeSmithOverlays(options) {
+    if (!options.overlays?.length) return;
+    const snapshot = captureOverlayBaselineSnapshot(options.workspaceRoot, resolveShellPackageDirectories(options.workspaceRoot));
+    for (const overlay of options.overlays){
+        runCodeSmithOverlay({
+            workspaceRoot: options.workspaceRoot,
+            overlay,
+            config: createOverlayRuntimeConfig(options.workspaceRoot, options.result)
+        });
+        assertOverlayPreservedBaseline({
+            workspaceRoot: options.workspaceRoot,
+            generator: overlay.generator,
+            snapshot
+        });
+    }
+}
+function runCodeSmithOverlay(options) {
+    const result = spawnSync(process.execPath, [
+        '--eval',
+        overlayRunnerSource
+    ], {
+        cwd: options.workspaceRoot,
+        encoding: 'utf8',
+        input: JSON.stringify({
+            workspaceRoot: options.workspaceRoot,
+            generator: options.overlay.generator,
+            codesmithModulePath: overlays_require.resolve('@modern-js/codesmith'),
+            config: {
+                ...options.overlay.config ?? {},
+                ...options.config
+            }
+        })
+    });
+    if (0 !== result.status) {
+        const detail = [
+            result.stderr.trim(),
+            result.stdout.trim()
+        ].filter(Boolean).join('\n');
+        throw new Error([
+            `UltraModern CodeSmith overlay failed: ${options.overlay.generator}`,
+            detail
+        ].filter(Boolean).join('\n'));
+    }
+}
+function createOverlayRuntimeConfig(outputWorkspaceRoot, result) {
+    const generatedApp = result.createdApps[0];
+    return {
+        workspaceRoot: result.workspaceRoot,
+        outputWorkspaceRoot,
+        packageScope: result.packageScope,
+        operation: result.operation,
+        generatedApp,
+        generatedApps: result.createdApps,
+        assignedPort: generatedApp ? result.assignedPorts[generatedApp.id] : void 0,
+        assignedPorts: result.assignedPorts,
+        moduleFederationName: generatedApp ? result.moduleFederationNames[generatedApp.id] : void 0,
+        moduleFederationNames: result.moduleFederationNames,
+        apiPrefix: generatedApp ? result.apiPrefixes[generatedApp.id] : void 0,
+        apiPrefixes: result.apiPrefixes,
+        packageSource: result.packageSource,
+        generationResult: result
+    };
+}
+export { runCodeSmithOverlays };

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

@@ -0,0 +1,202 @@
+import "node:module";
+import { ULTRAMODERN_CREATE_PACKAGE, WORKSPACE_PACKAGE_VERSION, modernPackageSpecifier } from "../ultramodern-package-source.js";
+import { appHasApi, remoteDependencyAlias, resolveApiProtocol, resolveRemoteRefs, shellApp, verticalApiApps, zephyrRemoteDependency } from "./descriptors.js";
+import { readFileTemplate } from "./fs-io.js";
+import { packageName, relativeRootFor } from "./naming.js";
+import { ULTRAMODERN_PACKAGE_PINS, ULTRAMODERN_WORKSPACE_POLICY } from "./policy.js";
+import { GENERATED_POSTINSTALL_SCRIPT, createStrictTsgoTypecheckCommand, createWorkspaceAppPackageScripts, createWorkspaceRootPackageScripts } from "./workspace-script-plan.js";
+function appDependencies(scope, packageSource, app, remotes = [], bridge) {
+    const dependencies = {
+        '@modern-js/plugin-tanstack': modernPackageSpecifier('@modern-js/plugin-tanstack', packageSource),
+        '@modern-js/plugin-i18n': modernPackageSpecifier('@modern-js/plugin-i18n', packageSource),
+        '@modern-js/runtime': modernPackageSpecifier('@modern-js/runtime', packageSource),
+        ...ULTRAMODERN_PACKAGE_PINS.appDependencies,
+        [packageName(scope, 'shared-contracts')]: WORKSPACE_PACKAGE_VERSION,
+        [packageName(scope, 'shared-design-tokens')]: WORKSPACE_PACKAGE_VERSION
+    };
+    const appRemotes = resolveRemoteRefs(app, remotes);
+    for (const dependency of bridge?.dependencies ?? []){
+        if (Object.hasOwn(dependencies, dependency)) throw new Error(`Bridge mode dependency "${dependency}" conflicts with generated app dependency.`);
+        dependencies[dependency] = WORKSPACE_PACKAGE_VERSION;
+    }
+    if ('shell' === app.kind) {
+        dependencies['@modern-js/plugin-bff'] = modernPackageSpecifier('@modern-js/plugin-bff', packageSource);
+        Object.assign(dependencies, ULTRAMODERN_PACKAGE_PINS.bffEffectDependencies);
+        for (const remote of verticalApiApps(remotes))dependencies[packageName(scope, remote.packageSuffix)] = WORKSPACE_PACKAGE_VERSION;
+    }
+    for (const remote of appRemotes)dependencies[packageName(scope, remote.packageSuffix)] = WORKSPACE_PACKAGE_VERSION;
+    if (appHasApi(app)) {
+        dependencies['@modern-js/plugin-bff'] = modernPackageSpecifier('@modern-js/plugin-bff', packageSource);
+        Object.assign(dependencies, ULTRAMODERN_PACKAGE_PINS.bffEffectDependencies);
+    }
+    return dependencies;
+}
+function appDevDependencies(packageSource, enableTailwind) {
+    const { '@rsbuild/plugin-tailwindcss': tailwindPluginVersion, tailwindcss: tailwindVersion, ...always } = ULTRAMODERN_PACKAGE_PINS.appDevDependencies;
+    return {
+        '@modern-js/app-tools': modernPackageSpecifier('@modern-js/app-tools', packageSource),
+        ...always,
+        ...enableTailwind ? {
+            '@rsbuild/plugin-tailwindcss': tailwindPluginVersion,
+            tailwindcss: tailwindVersion
+        } : {}
+    };
+}
+function createRootPackageJson(scope, packageSource, remotes = [], bridge, additionalShells = []) {
+    const shellFilter = `--filter ${packageName(scope, shellApp.packageSuffix)}`;
+    const additionalShellFilters = additionalShells.map((shell)=>`--filter ${packageName(scope, shell.packageSuffix)}`);
+    const remoteFilters = remotes.map((remote)=>`--filter ${packageName(scope, remote.packageSuffix)}`);
+    const bridgeScripts = bridge ? {
+        ...Object.fromEntries(bridge.gates.map((gate)=>[
+                `bridge:${gate.name}`,
+                `${gate.cwd ? `cd ${gate.cwd} && ` : ''}${gate.command}`
+            ])),
+        'bridge:check': bridge.gates.map((gate)=>`pnpm run bridge:${gate.name}`).join(' && ')
+    } : {};
+    const bridgeCheck = bridge ? ' && pnpm bridge:check' : '';
+    const bridgeTypecheck = bridge ? 'pnpm -r --filter "./apps/*" --filter "./verticals/*" --filter "./packages/*" run typecheck' : void 0;
+    const rootPackageScripts = createWorkspaceRootPackageScripts(remotes, {
+        bridgeCheck,
+        typecheck: bridgeTypecheck,
+        shells: [
+            shellApp,
+            ...additionalShells
+        ]
+    });
+    const workspacePackages = [
+        'apps/*',
+        'verticals/*',
+        'packages/*',
+        ...bridge?.workspacePackages.map((entry)=>entry.pattern) ?? []
+    ];
+    return {
+        private: true,
+        name: scope,
+        version: '0.1.0',
+        type: 'module',
+        packageManager: `pnpm@${ULTRAMODERN_WORKSPACE_POLICY.toolchain.packageManager.version}`,
+        scripts: {
+            dev: `pnpm --parallel ${[
+                shellFilter,
+                ...additionalShellFilters,
+                ...remoteFilters
+            ].join(' ')} dev`,
+            'dev:shell': `pnpm --filter ${packageName(scope, shellApp.packageSuffix)} dev`,
+            ...Object.fromEntries(additionalShells.map((shell)=>[
+                    `dev:${shell.packageSuffix}`,
+                    `pnpm --filter ${packageName(scope, shell.packageSuffix)} dev`
+                ])),
+            ...Object.fromEntries(remotes.map((remote)=>[
+                    `dev:${remote.packageSuffix}`,
+                    `pnpm --filter ${packageName(scope, remote.packageSuffix)} dev`
+                ])),
+            ...rootPackageScripts,
+            format: 'oxfmt .',
+            'format:check': 'oxfmt --check .',
+            lint: 'oxlint apps verticals packages',
+            'lint:fix': 'oxlint apps verticals packages --fix',
+            'skills:install': "node ./scripts/bootstrap-agent-skills.mts",
+            'skills:check': "node ./scripts/bootstrap-agent-skills.mts --check",
+            'agents:refs:install': "node ./scripts/setup-agent-reference-repos.mts",
+            'agents:refs:check': "node ./scripts/setup-agent-reference-repos.mts --check",
+            'api:check': "node ./scripts/check-ultramodern-api-boundaries.mts",
+            'i18n:boundaries': "node ./scripts/check-ultramodern-i18n-boundaries.mts",
+            ...bridgeScripts,
+            postinstall: GENERATED_POSTINSTALL_SCRIPT
+        },
+        engines: {
+            node: ULTRAMODERN_WORKSPACE_POLICY.toolchain.node.engineRange,
+            pnpm: ULTRAMODERN_WORKSPACE_POLICY.toolchain.packageManager.engineRange
+        },
+        workspaces: workspacePackages,
+        modernjs: {
+            preset: 'presetUltramodern',
+            workspace: 'ultramodern-superapp',
+            topology: './topology/reference-topology.json',
+            ownership: './topology/ownership.json',
+            packageSource: {
+                strategy: packageSource.strategy,
+                config: './.modernjs/ultramodern.json'
+            }
+        },
+        devDependencies: {
+            ...ULTRAMODERN_PACKAGE_PINS.rootDevDependencies,
+            '@modern-js/code-tools': modernPackageSpecifier('@modern-js/code-tools', packageSource),
+            [ULTRAMODERN_CREATE_PACKAGE]: modernPackageSpecifier(ULTRAMODERN_CREATE_PACKAGE, packageSource),
+            '@modern-js/plugin-bff': modernPackageSpecifier('@modern-js/plugin-bff', packageSource),
+            ...ULTRAMODERN_PACKAGE_PINS.bffEffectDependencies
+        }
+    };
+}
+function createZephyrDependencies(scope, app, remotes = []) {
+    if (!app.verticalRefs?.length) return {};
+    return Object.fromEntries(resolveRemoteRefs(app, remotes).map((remote)=>[
+            remoteDependencyAlias(remote),
+            zephyrRemoteDependency(scope, remote)
+        ]));
+}
+function createAppPackage(scope, app, packageSource, enableTailwind, remotes = [], bridge) {
+    const packageExports = Object.fromEntries(Object.entries(app.exposes ?? {}).map(([expose, source])=>[
+            expose,
+            source
+        ]));
+    const packageJson = {
+        private: true,
+        name: packageName(scope, app.packageSuffix),
+        version: '0.1.0',
+        scripts: createWorkspaceAppPackageScripts(app),
+        modernjs: {
+            preset: 'presetUltramodern',
+            role: 'shell' === app.kind ? 'shell' : 'module-federation-remote',
+            appId: app.id,
+            topology: `${relativeRootFor(app.directory)}/topology/reference-topology.json`,
+            ...appHasApi(app) ? {
+                apiRuntime: 'effect'
+            } : {}
+        },
+        'zephyr:dependencies': createZephyrDependencies(scope, app, remotes),
+        dependencies: appDependencies(scope, packageSource, app, remotes, bridge),
+        devDependencies: appDevDependencies(packageSource, enableTailwind)
+    };
+    if (appHasApi(app)) if ('rpc' === resolveApiProtocol(app)) Object.assign(packageExports, {
+        './api': './shared/rpc.ts',
+        './api/rpc-client': `./src/api/${app.api.stem}-rpc-client.ts`
+    });
+    else Object.assign(packageExports, {
+        './api': './shared/api.ts',
+        './api/client': `./src/api/${app.api.stem}-client.ts`
+    });
+    else if ('shell' === app.kind) Object.assign(packageExports, {
+        './api/clients': './src/api/vertical-clients.ts'
+    });
+    if (Object.keys(packageExports).length > 0) packageJson.exports = packageExports;
+    return packageJson;
+}
+function createSharedPackage(scope, id, description) {
+    const packageJson = {
+        private: true,
+        name: packageName(scope, id),
+        version: '0.1.0',
+        description,
+        type: 'module',
+        exports: {
+            '.': './src/index.ts'
+        },
+        scripts: {
+            typecheck: createStrictTsgoTypecheckCommand(`packages/${id}`)
+        },
+        devDependencies: {
+            '@effect/tsgo': ULTRAMODERN_PACKAGE_PINS.appDevDependencies["@effect/tsgo"]
+        }
+    };
+    if ('shared-design-tokens' === id) packageJson.exports = {
+        ...packageJson.exports,
+        './tokens.css': './src/tokens.css'
+    };
+    return packageJson;
+}
+function createSharedContractsIndex() {
+    return readFileTemplate('packages/shared-contracts-index.ts');
+}
+export { createAppMfTypesTsConfig, createAppTsConfig, createPackageTsConfig, createRootTsConfig, createSharedPackageTsConfig, createTsConfigBase } from "./tsconfigs.js";
+export { appDependencies, createAppPackage, createRootPackageJson, createSharedContractsIndex, createSharedPackage };

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

@@ -0,0 +1,28 @@
+import "node:module";
+import { BLEEDINGDEV_PACKAGE_NAME_PREFIX, BLEEDINGDEV_PACKAGE_SCOPE, WORKSPACE_PACKAGE_VERSION } from "../ultramodern-package-source.js";
+function resolvePackageSource(options) {
+    const strategy = options.packageSource?.strategy ?? 'install';
+    if ('workspace' === strategy) return {
+        strategy,
+        modernPackageVersion: WORKSPACE_PACKAGE_VERSION,
+        registry: options.packageSource?.registry,
+        aliasScope: options.packageSource?.aliasScope,
+        aliasPackageNamePrefix: options.packageSource?.aliasPackageNamePrefix
+    };
+    const registry = options.packageSource?.registry;
+    const aliasScope = options.packageSource?.aliasScope ?? (registry ? void 0 : BLEEDINGDEV_PACKAGE_SCOPE);
+    return {
+        strategy,
+        modernPackageVersion: options.packageSource?.modernPackageVersion ?? options.modernVersion,
+        registry,
+        aliasScope,
+        aliasPackageNamePrefix: options.packageSource?.aliasPackageNamePrefix ?? (aliasScope ? BLEEDINGDEV_PACKAGE_NAME_PREFIX : void 0)
+    };
+}
+function resolveWorkspacePackageLinkingPolicy(packageSource) {
+    return 'workspace' === packageSource.strategy ? {
+        injectWorkspacePackages: true,
+        linkWorkspacePackages: true
+    } : {};
+}
+export { resolvePackageSource, resolveWorkspacePackageLinkingPolicy };