@bleedingdev/modern-js-app-tools-extensions 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

package/src/build-config/precompress/plugin.ts

@@ -0,0 +1,140 @@
+import { constants as zlibConstants } from 'node:zlib';
+import type { RsbuildPlugin } from '@rsbuild/core';
+import CompressionPlugin from 'compression-webpack-plugin';
+import type { PrecompressConfig } from './types';
+
+export type { PrecompressCodecOptions, PrecompressConfig } from './types';
+
+type CompressionPluginOptions = NonNullable<
+  ConstructorParameters<typeof CompressionPlugin>[0]
+>;
+
+const DEFAULT_PRECOMPRESS_TEST = /\.(js|mjs|cjs|css|html|svg|json|map)$/i;
+const DEFAULT_PRECOMPRESS_THRESHOLD = 10 * 1024;
+const DEFAULT_PRECOMPRESS_MIN_RATIO = 0.8;
+
+const createDefaultGzipOptions = (): CompressionPluginOptions => ({
+  algorithm: 'gzip',
+  filename: '[path][base].gz',
+  test: DEFAULT_PRECOMPRESS_TEST,
+  threshold: DEFAULT_PRECOMPRESS_THRESHOLD,
+  minRatio: DEFAULT_PRECOMPRESS_MIN_RATIO,
+  compressionOptions: {
+    level: 6,
+  },
+});
+
+const createDefaultBrotliOptions = (): CompressionPluginOptions => ({
+  algorithm: 'brotliCompress',
+  filename: '[path][base].br',
+  test: DEFAULT_PRECOMPRESS_TEST,
+  threshold: DEFAULT_PRECOMPRESS_THRESHOLD,
+  minRatio: DEFAULT_PRECOMPRESS_MIN_RATIO,
+  compressionOptions: {
+    params: {
+      [zlibConstants.BROTLI_PARAM_QUALITY]: 9,
+    },
+  },
+});
+
+const mergeCompressionOptions = (
+  base: CompressionPluginOptions,
+  next: Partial<CompressionPluginOptions>,
+): CompressionPluginOptions => {
+  const merged = {
+    ...base,
+    ...next,
+  };
+
+  if (base.compressionOptions || next.compressionOptions) {
+    const baseCompressionOptions = base.compressionOptions as
+      | Record<string, unknown>
+      | undefined;
+    const nextCompressionOptions = next.compressionOptions as
+      | Record<string, unknown>
+      | undefined;
+    const mergedCompressionOptions = {
+      ...baseCompressionOptions,
+      ...nextCompressionOptions,
+    };
+
+    if (baseCompressionOptions?.params || nextCompressionOptions?.params) {
+      mergedCompressionOptions.params = {
+        ...(baseCompressionOptions?.params as Record<string, unknown>),
+        ...(nextCompressionOptions?.params as Record<string, unknown>),
+      };
+    }
+
+    merged.compressionOptions = mergedCompressionOptions;
+  }
+
+  return merged;
+};
+
+const resolveCodecOptions = (
+  codecConfig: PrecompressConfig['gzip'] | PrecompressConfig['brotli'],
+  createDefaultOptions: () => CompressionPluginOptions,
+): CompressionPluginOptions | null => {
+  if (codecConfig === false) {
+    return null;
+  }
+
+  if (codecConfig === undefined || codecConfig === true) {
+    return createDefaultOptions();
+  }
+
+  return mergeCompressionOptions(createDefaultOptions(), codecConfig);
+};
+
+const resolvePrecompressConfig = (
+  precompress: boolean | PrecompressConfig | undefined,
+): PrecompressConfig | false => {
+  if (precompress === false || precompress === undefined) {
+    return false;
+  }
+
+  if (precompress === true) {
+    return {};
+  }
+
+  return precompress;
+};
+
+export const builderPluginAdapterPrecompress = (
+  precompress: boolean | PrecompressConfig | undefined,
+): RsbuildPlugin => ({
+  name: 'builder-plugin-adapter-modern-precompress',
+
+  setup(api) {
+    api.modifyBundlerChain((chain, { isProd, target }) => {
+      if (!isProd || target !== 'web') {
+        return;
+      }
+
+      const precompressConfig = resolvePrecompressConfig(precompress);
+      if (precompressConfig === false) {
+        return;
+      }
+
+      const gzipOptions = resolveCodecOptions(
+        precompressConfig.gzip,
+        createDefaultGzipOptions,
+      );
+      if (gzipOptions) {
+        chain
+          .plugin('modern-precompress-gzip')
+          .use(CompressionPlugin, [gzipOptions]);
+      }
+
+      const brotliOptions = resolveCodecOptions(
+        precompressConfig.brotli,
+        createDefaultBrotliOptions,
+      );
+      if (brotliOptions) {
+        chain
+          .plugin('modern-precompress-brotli')
+          .use(CompressionPlugin, [brotliOptions]);
+      }
+    });
+  },
+});

package/src/build-config/precompress/types.ts

@@ -0,0 +1,26 @@
+import type CompressionPlugin from 'compression-webpack-plugin';
+
+type CompressionPluginOptions = NonNullable<
+  ConstructorParameters<typeof CompressionPlugin>[0]
+>;
+
+export type PrecompressCodecOptions =
+  | boolean
+  | Partial<CompressionPluginOptions>;
+
+export interface PrecompressConfig {
+  /**
+   * Configure gzip precompression options.
+   * `true` means using default options.
+   * `false` means disabling gzip precompression.
+   * @default true
+   */
+  gzip?: PrecompressCodecOptions;
+  /**
+   * Configure brotli precompression options.
+   * `true` means using default options.
+   * `false` means disabling brotli precompression.
+   * @default true
+   */
+  brotli?: PrecompressCodecOptions;
+}

package/src/build-config/public.ts

@@ -0,0 +1,6 @@
+export type { ResolveEffectTsgoCompilerOptions } from './build-environment';
+export {
+  getBuildConfigEnvironment,
+  resolveEffectTsgoCompiler,
+  withBuildConfigEnvironment,
+} from './build-environment';

package/src/cloudflare/constants.ts

@@ -34,7 +34,7 @@ export const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_
 export const BFF_EFFECT_WORKER_DISPATCHER_EXPORT =
   '__modern_create_effect_bff_dispatcher';
 export const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE =
-  'Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.';
+  'Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/bff-effect/effect-edge instead of lambda/Hono server helpers.';
 export const DEFAULT_COMPATIBILITY_DATE = '2026-06-02';
 export const COMPATIBILITY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
 export const REQUIRED_COMPATIBILITY_FLAGS =

package/src/cloudflare/delivery-unit.ts

@@ -1,13 +1,12 @@
 import path from 'node:path';
-import { fs as fse } from '@modern-js/utils';
 import {
   type DeliveryUnitIdentity,
   isUltramodernBuildArtifact,
   nonEmptyString,
   toDeliveryUnitIdentity,
   ULTRAMODERN_BUILD_ARTIFACT_PATH,
-  ULTRAMODERN_BUILD_MODULE_PATH,
-} from '@modern-js/utils/universal';
+} from '@modern-js/backend-federation-contracts';
+import { fs as fse } from '@modern-js/utils';
 import { resolveUltramodernReleaseIdentity } from '../release-identity';
 import { isRecord } from './utils';
 
@@ -148,7 +147,7 @@ export const resolveTopologyDeliveryUnit = async (
 
 /**
  * Resolve the delivery-unit identity actually bundled into the worker by
- * parsing the generated `shared/ultramodern-build.ts` module. This is the
+ * reading the generated `shared/ultramodern-build.json` artifact. This is the
  * worker snapshot / declared surface source that gets stamped into the manifest.
  */
 export const resolveWorkerDeliveryUnitStamp = async (
@@ -158,10 +157,6 @@ export const resolveWorkerDeliveryUnitStamp = async (
     appDirectory,
     ULTRAMODERN_BUILD_ARTIFACT_PATH,
   );
-  const buildModulePath = path.join(
-    appDirectory,
-    ULTRAMODERN_BUILD_MODULE_PATH,
-  );
   let identity: DeliveryUnitIdentity | undefined;
 
   if (await fse.pathExists(buildArtifactPath)) {
@@ -170,18 +165,6 @@ export const resolveWorkerDeliveryUnitStamp = async (
       return undefined;
     }
     identity = toDeliveryUnitIdentity(artifact.deliveryUnit);
-  } else if (await fse.pathExists(buildModulePath)) {
-    console.warn(
-      `[cloudflare] ${buildArtifactPath} missing; falling back to legacy regex parsing of ${buildModulePath}. Regenerate the workspace to emit ultramodern-build.json.`,
-    );
-    const source = await fse.readFile(buildModulePath, 'utf8');
-    identity = toDeliveryUnitIdentity({
-      buildMarker: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
-      unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
-      sourceRevision: source.match(
-        /\bsourceRevision:\s*['"]([^'"]+)['"]/u,
-      )?.[1],
-    });
   }
 
   if (!identity) {

package/src/cloudflare/worker-manifest.ts

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import type {} from '@modern-js/server-runtime-extensions/server-config';
 import { fs as fse } from '@modern-js/utils';
 import { readRouteSpec } from './artifacts';
 import {

package/src/cloudflare-builder.ts

@@ -3,6 +3,7 @@ import { createRequire } from 'node:module';
 import path from 'node:path';
 import { SERVICE_WORKER_ENVIRONMENT_NAME } from '@modern-js/builder';
 import type { BffUserConfig } from '@modern-js/server-core';
+import type {} from '@modern-js/server-runtime-extensions/server-config';
 import { isProd } from '@modern-js/utils';
 import type {
   EnvironmentConfig,

package/src/cloudflare-output-contract.ts

@@ -10,19 +10,56 @@ export const CLOUDFLARE_RUNTIME_TYPE = 'cloudflare-module-worker';
 export const CLOUDFLARE_OUTPUT_PACKAGE_TYPE = 'module';
 export const CLOUDFLARE_WORKER_PACKAGE_TYPE = 'commonjs';
 export const CLOUDFLARE_WORKER_BUNDLE_FORMAT = 'commonjs';
+// Import availability for the default 2026-06-02 nodejs_compat target.
+// Some modules are runtime-provided stubs whose unsupported operations throw.
 export const CLOUDFLARE_WORKER_NODE_BUILTINS = [
+  'assert',
+  'assert/strict',
   'async_hooks',
   'buffer',
+  'child_process',
   'crypto',
+  'dgram',
+  'dns',
+  'domain',
   'events',
+  'fs',
   'fs/promises',
+  'http',
+  'http2',
+  'inspector',
   'module',
+  'net',
+  'os',
   'path',
   'process',
+  'readline',
+  'readline/promises',
+  'repl',
+  'sqlite',
   'stream',
+  'stream/consumers',
+  'stream/promises',
+  'stream/web',
   'string_decoder',
+  'timers',
+  'timers/promises',
+  'tls',
+  'trace_events',
+  'tty',
   'url',
   'util',
+  'util/types',
+  'v8',
+  'vm',
+  'wasi',
+  'worker_threads',
+  'zlib',
+] as const;
+// Platform imports available with the default 2026-06-02 nodejs_compat target.
+// Import availability does not imply support for every Node API operation.
+export const CLOUDFLARE_WORKER_PLATFORM_MODULES = [
+  'cloudflare:sockets',
 ] as const;
 export const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS = [
   'nodejs_compat',

package/src/cloudflare-output-verifier/identity.ts

@@ -2,7 +2,7 @@ import {
   DELIVERY_UNIT_IDENTITY_FIELDS,
   type DeliveryUnitIdentity,
   deliveryUnitIdentityFieldValue,
-} from '@modern-js/utils/universal';
+} from '@modern-js/backend-federation-contracts';
 import type { CloudflareOutputVerifierIssue, JsonObject } from './issues';
 import { addIssue, assertEqual } from './issues';
 

package/src/cloudflare-output-verifier/worker-bundles.ts

@@ -7,6 +7,7 @@ import traverse, { type NodePath } from '@babel/traverse';
 import {
   CLOUDFLARE_WORKER_BUNDLE_DIRECTORY,
   CLOUDFLARE_WORKER_NODE_BUILTINS,
+  CLOUDFLARE_WORKER_PLATFORM_MODULES,
 } from '../cloudflare-output-contract';
 import type { CloudflareOutputVerifierIssue, JsonObject } from './issues';
 import { addIssue } from './issues';
@@ -436,9 +437,10 @@ const getPackageName = (specifier: string) =>
     ? specifier.split('/').slice(0, 2).join('/')
     : specifier.split('/')[0];
 
-const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set(
-  CLOUDFLARE_WORKER_NODE_BUILTINS.map(builtin => `node:${builtin}`),
-);
+const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set([
+  ...CLOUDFLARE_WORKER_NODE_BUILTINS.map(builtin => `node:${builtin}`),
+  ...CLOUDFLARE_WORKER_PLATFORM_MODULES,
+]);
 
 const isInsideDirectory = (directory: string, filePath: string) => {
   const relative = path.relative(directory, filePath);

package/src/config.ts

@@ -1,3 +1,10 @@
+export type { ResolveEffectTsgoCompilerOptions } from './build-config/public';
+export {
+  getBuildConfigEnvironment,
+  resolveEffectTsgoCompiler,
+  withBuildConfigEnvironment,
+} from './build-config/public';
+
 export type DeployTarget =
   | 'node'
   | 'vercel'

package/src/deploy-output/npmAliases.ts

@@ -0,0 +1,333 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+type PackageJson = {
+  name?: string;
+  version?: string;
+  dependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
+  [key: string]: unknown;
+};
+
+type PackageRecord = {
+  directory: string;
+  packageJson: PackageJson;
+};
+
+export type NpmAlias = {
+  aliasName: string;
+  targetName: string;
+  targetVersion: string;
+};
+
+const dependencyKeys = ['dependencies', 'optionalDependencies'] as const;
+const exactVersionPattern =
+  /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
+
+async function readPackageJson(filePath: string): Promise<PackageJson> {
+  return JSON.parse(await fs.readFile(filePath, 'utf8')) as PackageJson;
+}
+
+function parseNpmAlias(
+  aliasName: string,
+  specifier: string,
+): NpmAlias | undefined {
+  if (!specifier.startsWith('npm:')) {
+    return undefined;
+  }
+
+  const target = specifier.slice('npm:'.length);
+  const versionSeparator = target.lastIndexOf('@');
+  if (versionSeparator <= 0 || versionSeparator === target.length - 1) {
+    throw new Error(
+      `Invalid npm alias specifier for ${aliasName}: ${specifier}`,
+    );
+  }
+
+  return {
+    aliasName,
+    targetName: target.slice(0, versionSeparator),
+    targetVersion: target.slice(versionSeparator + 1),
+  };
+}
+
+function aliasesFromPackageJson(packageJson: PackageJson): NpmAlias[] {
+  const aliases: NpmAlias[] = [];
+  for (const dependencyKey of dependencyKeys) {
+    for (const [aliasName, specifier] of Object.entries(
+      packageJson[dependencyKey] ?? {},
+    )) {
+      const alias = parseNpmAlias(aliasName, specifier);
+      if (alias) {
+        aliases.push(alias);
+      }
+    }
+  }
+  return aliases;
+}
+
+async function collectPackageRecords(
+  nodeModulesDirectory: string,
+): Promise<PackageRecord[]> {
+  const records: PackageRecord[] = [];
+  const visitedNodeModules = new Set<string>();
+
+  const visitPackage = async (directory: string) => {
+    const packageJsonPath = path.join(directory, 'package.json');
+    try {
+      const packageJson = await readPackageJson(packageJsonPath);
+      if (packageJson.name && packageJson.version) {
+        records.push({ directory, packageJson });
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw error;
+      }
+    }
+    await visitNodeModules(path.join(directory, 'node_modules'));
+  };
+
+  const visitScope = async (scopeDirectory: string) => {
+    const entries = await fs.readdir(scopeDirectory, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        await visitPackage(path.join(scopeDirectory, entry.name));
+      }
+    }
+  };
+
+  const visitNdepeStore = async (storeDirectory: string) => {
+    const entries = await fs.readdir(storeDirectory, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const entryPath = path.join(storeDirectory, entry.name);
+        if (entry.name.startsWith('@')) {
+          // ndepe preserves the slash in a scoped package name, so a
+          // multi-version package is stored as
+          // .ndepe/@scope/package@version/node_modules/@scope/package.
+          await visitScope(entryPath);
+        } else {
+          await visitNodeModules(path.join(entryPath, 'node_modules'));
+        }
+      }
+    }
+  };
+
+  const visitNodeModules = async (directory: string): Promise<void> => {
+    const resolvedDirectory = path.resolve(directory);
+    if (visitedNodeModules.has(resolvedDirectory)) {
+      return;
+    }
+    visitedNodeModules.add(resolvedDirectory);
+
+    let entries;
+    try {
+      entries = await fs.readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        return;
+      }
+      throw error;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const entryPath = path.join(directory, entry.name);
+      if (entry.name === '.ndepe') {
+        await visitNdepeStore(entryPath);
+      } else if (entry.name.startsWith('@')) {
+        await visitScope(entryPath);
+      } else {
+        await visitPackage(entryPath);
+      }
+    }
+  };
+
+  await visitNodeModules(nodeModulesDirectory);
+  return records;
+}
+
+async function resolveAliasTarget(
+  ownerDirectory: string,
+  alias: NpmAlias,
+  outputDirectory: string,
+): Promise<PackageRecord | undefined> {
+  let directory = ownerDirectory;
+  const outputRoot = path.resolve(outputDirectory);
+  const resolvedOutputRoot = await fs.realpath(outputRoot);
+  while (
+    directory === outputRoot ||
+    directory.startsWith(`${outputRoot}${path.sep}`)
+  ) {
+    const candidate = path.join(directory, 'node_modules', alias.targetName);
+    try {
+      const resolvedCandidate = await fs.realpath(candidate);
+      if (
+        resolvedCandidate !== resolvedOutputRoot &&
+        !resolvedCandidate.startsWith(`${resolvedOutputRoot}${path.sep}`)
+      ) {
+        throw new Error(
+          `Cannot preserve npm alias ${alias.aliasName}: emitted target ${candidate} resolves outside deployment output to ${resolvedCandidate}`,
+        );
+      }
+      const packageJson = await readPackageJson(
+        path.join(candidate, 'package.json'),
+      );
+      if (packageJson.name !== alias.targetName || !packageJson.version) {
+        throw new Error(
+          `npm alias ${alias.aliasName} resolved ${candidate} to unexpected package ${String(packageJson.name)}`,
+        );
+      }
+      if (
+        exactVersionPattern.test(alias.targetVersion) &&
+        packageJson.version !== alias.targetVersion
+      ) {
+        return undefined;
+      }
+      // Keep the lexical path inside .output. realpath can cross an operating
+      // system alias such as macOS /var -> /private/var, which would turn the
+      // deployment link into a non-relocatable path outside the artifact.
+      return { directory: candidate, packageJson };
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw error;
+      }
+    }
+    if (directory === outputRoot) {
+      break;
+    }
+    directory = path.dirname(directory);
+  }
+  return undefined;
+}
+
+async function ensureAliasLink(
+  ownerDirectory: string,
+  alias: NpmAlias,
+  target: PackageRecord,
+) {
+  const aliasPath = path.join(ownerDirectory, 'node_modules', alias.aliasName);
+  await fs.mkdir(path.dirname(aliasPath), { recursive: true });
+
+  try {
+    const [existing, expected] = await Promise.all([
+      fs.realpath(aliasPath),
+      fs.realpath(target.directory),
+    ]);
+    if (existing === expected) {
+      return;
+    }
+    throw new Error(
+      `Cannot preserve npm alias ${alias.aliasName}: ${aliasPath} already resolves to ${existing}, expected ${expected}`,
+    );
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  const linkTarget = path.relative(path.dirname(aliasPath), target.directory);
+  await fs.symlink(linkTarget, aliasPath, 'dir');
+}
+
+function aliasSpecifier(alias: NpmAlias) {
+  return `npm:${alias.targetName}@${alias.targetVersion}`;
+}
+
+export async function readPackageIdentity(
+  entryPath: string,
+): Promise<{ name: string; version: string }> {
+  let directory = path.dirname(entryPath);
+  const root = path.parse(directory).root;
+  while (directory !== root) {
+    try {
+      const packageJson = await readPackageJson(
+        path.join(directory, 'package.json'),
+      );
+      if (packageJson.name && packageJson.version) {
+        return { name: packageJson.name, version: packageJson.version };
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw error;
+      }
+    }
+    directory = path.dirname(directory);
+  }
+  throw new Error(
+    `Cannot find owning package for deployment entry ${entryPath}`,
+  );
+}
+
+export async function preserveNpmAliases({
+  appDirectory,
+  outputDirectory,
+  implicitAliases = [],
+}: {
+  appDirectory: string;
+  outputDirectory: string;
+  implicitAliases?: NpmAlias[];
+}) {
+  const records = await collectPackageRecords(
+    path.join(outputDirectory, 'node_modules'),
+  );
+
+  const appPackageJson = await readPackageJson(
+    path.join(appDirectory, 'package.json'),
+  );
+  const rootAliases = [
+    ...aliasesFromPackageJson(appPackageJson),
+    ...implicitAliases,
+  ].filter(alias => alias.aliasName !== alias.targetName);
+
+  const emittedRootAliases: NpmAlias[] = [];
+  for (const alias of rootAliases) {
+    const target = await resolveAliasTarget(
+      outputDirectory,
+      alias,
+      outputDirectory,
+    );
+    if (!target) {
+      if (implicitAliases.includes(alias)) {
+        throw new Error(
+          `Cannot preserve implicit npm alias ${alias.aliasName}: emitted target ${alias.targetName}@${alias.targetVersion} is missing`,
+        );
+      }
+      continue;
+    }
+    await ensureAliasLink(outputDirectory, alias, target);
+    emittedRootAliases.push(alias);
+  }
+
+  for (const record of records) {
+    for (const alias of aliasesFromPackageJson(record.packageJson).filter(
+      candidate => candidate.aliasName !== candidate.targetName,
+    )) {
+      const target = await resolveAliasTarget(
+        record.directory,
+        alias,
+        outputDirectory,
+      );
+      if (!target) {
+        // ndepe emits only runtime-traced packages. A package manifest can
+        // still declare type-only or otherwise unused aliases whose targets
+        // correctly are not part of this deployment output.
+        continue;
+      }
+      await ensureAliasLink(record.directory, alias, target);
+    }
+  }
+
+  const outputPackageJsonPath = path.join(outputDirectory, 'package.json');
+  const outputPackageJson = await readPackageJson(outputPackageJsonPath);
+  outputPackageJson.dependencies ??= {};
+  for (const alias of emittedRootAliases) {
+    outputPackageJson.dependencies[alias.aliasName] = aliasSpecifier(alias);
+  }
+  await fs.writeFile(
+    outputPackageJsonPath,
+    `${JSON.stringify(outputPackageJson, null, 2)}\n`,
+  );
+}