@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/src/deploy-output/npmAliases.ts

@@ -5,6 +5,7 @@ type PackageJson = {
   name?: string;
   version?: string;
   dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
   optionalDependencies?: Record<string, string>;
   [key: string]: unknown;
 };
@@ -21,6 +22,7 @@ export type NpmAlias = {
 };
 
 const dependencyKeys = ['dependencies', 'optionalDependencies'] as const;
+const rootDependencyKeys = [...dependencyKeys, 'devDependencies'] as const;
 const exactVersionPattern =
   /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
 
@@ -51,9 +53,12 @@ function parseNpmAlias(
   };
 }
 
-function aliasesFromPackageJson(packageJson: PackageJson): NpmAlias[] {
+function aliasesFromPackageJson(
+  packageJson: PackageJson,
+  keys: readonly (typeof rootDependencyKeys)[number][] = dependencyKeys,
+): NpmAlias[] {
   const aliases: NpmAlias[] = [];
-  for (const dependencyKey of dependencyKeys) {
+  for (const dependencyKey of keys) {
     for (const [aliasName, specifier] of Object.entries(
       packageJson[dependencyKey] ?? {},
     )) {
@@ -66,6 +71,119 @@ function aliasesFromPackageJson(packageJson: PackageJson): NpmAlias[] {
   return aliases;
 }
 
+async function catalogAliasesFromInstalledPackages(
+  appDirectory: string,
+  packageJson: PackageJson,
+): Promise<NpmAlias[]> {
+  const aliases: NpmAlias[] = [];
+  for (const dependencyKey of rootDependencyKeys) {
+    for (const [aliasName, specifier] of Object.entries(
+      packageJson[dependencyKey] ?? {},
+    )) {
+      if (!specifier.startsWith('catalog:')) {
+        continue;
+      }
+      let installedPackage: PackageJson;
+      try {
+        installedPackage = await readPackageJson(
+          path.join(appDirectory, 'node_modules', aliasName, 'package.json'),
+        );
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+          continue;
+        }
+        throw error;
+      }
+      if (!installedPackage.name || !installedPackage.version) {
+        throw new Error(
+          `Installed catalog package ${aliasName} has no identity`,
+        );
+      }
+      if (installedPackage.name !== aliasName) {
+        aliases.push({
+          aliasName,
+          targetName: installedPackage.name,
+          targetVersion: installedPackage.version,
+        });
+      }
+    }
+  }
+  return aliases;
+}
+
+// Overrides change the installed identity without changing the consumer's
+// dependency specifier. Read source edges to restore names after emission.
+async function installedAliasesByOwner(
+  appDirectory: string,
+  emittedOwners: Set<string>,
+) {
+  const aliasesByOwner = new Map<string, NpmAlias[]>();
+  let rootAliases: NpmAlias[] = [];
+  const visited = new Set<string>();
+  const rootFile = await fs.realpath(path.join(appDirectory, 'package.json'));
+  const pending = [rootFile];
+  while (pending.length) {
+    const file = await fs.realpath(pending.pop()!);
+    if (visited.has(file)) continue;
+    visited.add(file);
+    const owner = await readPackageJson(file);
+    const aliases: NpmAlias[] = [];
+    const keys = file === rootFile ? rootDependencyKeys : dependencyKeys;
+    for (const key of keys) {
+      for (const name of Object.keys(owner[key] ?? {})) {
+        let directory = path.dirname(file);
+        while (true) {
+          const packageFile = path.join(
+            directory,
+            'node_modules',
+            name,
+            'package.json',
+          );
+          let target: PackageJson;
+          try {
+            target = await readPackageJson(packageFile);
+          } catch (error) {
+            if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+            const parent = path.dirname(directory);
+            if (parent === directory) break;
+            directory = parent;
+            continue;
+          }
+          if (!target.name || !target.version) {
+            throw new Error(`Installed package ${name} has no identity`);
+          }
+          pending.push(packageFile);
+          if (target.name !== name) {
+            aliases.push({
+              aliasName: name,
+              targetName: target.name,
+              targetVersion: target.version,
+            });
+          }
+          break;
+        }
+      }
+    }
+    if (file === rootFile) rootAliases = aliases;
+    const identity = `${owner.name}@${owner.version}`;
+    if (emittedOwners.has(identity)) {
+      const existing = aliasesByOwner.get(identity);
+      const normalized = (items: NpmAlias[]) =>
+        items
+          .map(item => `${item.aliasName}=${aliasSpecifier(item)}`)
+          .sort()
+          .join('\n');
+      if (existing && normalized(existing) !== normalized(aliases)) {
+        throw new Error(
+          `Cannot preserve npm aliases for ${identity}: installed contexts resolve different dependency identities`,
+        );
+      }
+      aliasesByOwner.set(identity, aliases);
+    }
+  }
+  return { aliasesByOwner, rootAliases };
+}
+
 async function collectPackageRecords(
   nodeModulesDirectory: string,
 ): Promise<PackageRecord[]> {
@@ -277,8 +395,21 @@ export async function preserveNpmAliases({
   const appPackageJson = await readPackageJson(
     path.join(appDirectory, 'package.json'),
   );
+  const installedAliases = await installedAliasesByOwner(
+    appDirectory,
+    new Set(
+      records.map(
+        ({ packageJson }) => `${packageJson.name}@${packageJson.version}`,
+      ),
+    ),
+  );
   const rootAliases = [
-    ...aliasesFromPackageJson(appPackageJson),
+    ...aliasesFromPackageJson(appPackageJson, rootDependencyKeys),
+    ...installedAliases.rootAliases,
+    ...(await catalogAliasesFromInstalledPackages(
+      appDirectory,
+      appPackageJson,
+    )),
     ...implicitAliases,
   ].filter(alias => alias.aliasName !== alias.targetName);
 
@@ -302,7 +433,13 @@ export async function preserveNpmAliases({
   }
 
   for (const record of records) {
-    for (const alias of aliasesFromPackageJson(record.packageJson).filter(
+    const ownerAliases = [
+      ...aliasesFromPackageJson(record.packageJson),
+      ...(installedAliases.aliasesByOwner.get(
+        `${record.packageJson.name}@${record.packageJson.version}`,
+      ) ?? []),
+    ];
+    for (const alias of ownerAliases.filter(
       candidate => candidate.aliasName !== candidate.targetName,
     )) {
       const target = await resolveAliasTarget(

package/src/deploy-output/plugin.ts

@@ -1,35 +1,34 @@
 import { createRequire } from 'node:module';
 import path from 'node:path';
+import type { NodePublicAssetConfig } from '../config';
 import { preserveNpmAliases, readPackageIdentity } from './npmAliases';
 import {
-  type DeployOutputConfig,
-  resolveDeployTarget as defaultResolveDeployTarget,
-} from './target';
+  NODE_PUBLIC_ASSET_SCOPE,
+  normalizeDeclaredPublicAssets,
+  stageDeclaredPublicAssets,
+} from './public-assets';
+import { getDeployingTarget, type ResolvedDeployTarget } from './target';
+
+export interface DeployOutputAppContext {
+  appDirectory: string;
+  metaName: string;
+  deployTarget?: ResolvedDeployTarget;
+}
 
 export interface DeployOutputPluginApi {
-  getAppContext(): { appDirectory: string; metaName: string };
-  getNormalizedConfig(): DeployOutputConfig;
+  getAppContext(): DeployOutputAppContext;
   onAfterDeploy(handler: () => Promise<void>): void;
 }
 
-export const createDeployOutputAliasesPlugin = ({
-  resolveDeployTarget = defaultResolveDeployTarget,
-}: {
-  resolveDeployTarget?: (config: DeployOutputConfig) => string;
-} = {}) => ({
+export const createDeployOutputAliasesPlugin = () => ({
   name: '@modern-js/deploy-output-aliases',
   setup(api: DeployOutputPluginApi) {
     api.onAfterDeploy(async () => {
-      const { appDirectory, metaName } = api.getAppContext();
-      const config = api.getNormalizedConfig();
-      if (
-        (metaName !== 'modern-js' &&
-          !config.deploy?.target &&
-          !process.env.MODERNJS_DEPLOY) ||
-        resolveDeployTarget(config) !== 'node'
-      ) {
+      const appContext = api.getAppContext();
+      if (getDeployingTarget(appContext) !== 'node') {
         return;
       }
+      const { appDirectory } = appContext;
 
       const entry = createRequire(__filename).resolve('@modern-js/prod-server');
       const identity = await readPackageIdentity(entry);
@@ -47,3 +46,41 @@ export const createDeployOutputAliasesPlugin = ({
     });
   },
 });
+
+export interface DeployOutputPublicAssetsConfig {
+  deploy?: { node?: { publicAssets?: NodePublicAssetConfig[] } };
+}
+
+export interface DeployOutputPublicAssetsPluginApi {
+  getAppContext(): DeployOutputAppContext;
+  getNormalizedConfig(): DeployOutputPublicAssetsConfig;
+  onAfterDeploy(handler: () => Promise<void>): void;
+}
+
+/**
+ * Stage `deploy.node.publicAssets` into the Node deploy output. Cloudflare
+ * stages `deploy.worker.publicAssets` inside its deploy preset.
+ */
+export const createDeployOutputPublicAssetsPlugin = () => ({
+  name: '@modern-js/deploy-output-public-assets',
+  setup(api: DeployOutputPublicAssetsPluginApi) {
+    api.onAfterDeploy(async () => {
+      const appContext = api.getAppContext();
+      if (getDeployingTarget(appContext) !== 'node') {
+        return;
+      }
+      const { appDirectory } = appContext;
+      const config = api.getNormalizedConfig();
+
+      await stageDeclaredPublicAssets({
+        appDirectory,
+        outputDirectory: path.join(appDirectory, '.output'),
+        assets: normalizeDeclaredPublicAssets(
+          config.deploy?.node?.publicAssets,
+          NODE_PUBLIC_ASSET_SCOPE,
+        ),
+        scope: NODE_PUBLIC_ASSET_SCOPE,
+      });
+    });
+  },
+});

package/src/deploy-output/public-assets.ts

@@ -0,0 +1,224 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeRelativePath } from '../cloudflare/utils';
+
+/**
+ * Deploy output directory that receives declared public assets on every
+ * target: Cloudflare Worker Static Assets and the Node deploy output.
+ */
+export const DECLARED_PUBLIC_ASSET_DIRECTORY = 'public';
+
+export interface DeclaredPublicAssetConfig {
+  from: string;
+  to: string;
+}
+
+export interface DeclaredPublicAssetScope {
+  /** Config path used in errors, for example `deploy.node.publicAssets`. */
+  label: string;
+  /** Output described in destination errors. */
+  output: string;
+}
+
+export interface DeclaredPublicAsset {
+  from: string;
+  to: string;
+  index: number;
+}
+
+export const CLOUDFLARE_PUBLIC_ASSET_SCOPE: DeclaredPublicAssetScope = {
+  label: 'deploy.worker.publicAssets',
+  output: 'Cloudflare public output',
+};
+
+export const NODE_PUBLIC_ASSET_SCOPE: DeclaredPublicAssetScope = {
+  label: 'deploy.node.publicAssets',
+  output: 'Node public output',
+};
+
+export const normalizeDeclaredPublicAssets = (
+  assets: readonly DeclaredPublicAssetConfig[] | undefined,
+  scope: DeclaredPublicAssetScope,
+): DeclaredPublicAsset[] =>
+  (assets ?? []).map((asset, index) => ({
+    from: normalizeRelativePath(
+      asset?.from,
+      `${scope.label}[${index}].from`,
+      'app root',
+    ),
+    to: normalizeRelativePath(
+      asset?.to,
+      `${scope.label}[${index}].to`,
+      scope.output,
+      { allowRoot: true },
+    ),
+    index,
+  }));
+
+interface DeclaredPublicAssetFile {
+  index: number;
+  /** Destination relative to the deploy output root, POSIX separators. */
+  logicalPath: string;
+}
+
+const isMissingPathError = (error: unknown) =>
+  error instanceof Error &&
+  'code' in error &&
+  (error as NodeJS.ErrnoException).code === 'ENOENT';
+
+const pathExists = async (filePath: string) => {
+  try {
+    await fs.lstat(filePath);
+    return true;
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return false;
+    }
+    throw error;
+  }
+};
+
+const listDeclaredPublicAssetFiles = async (
+  appDirectory: string,
+  assets: readonly DeclaredPublicAsset[],
+  scope: DeclaredPublicAssetScope,
+): Promise<DeclaredPublicAssetFile[]> => {
+  const files: DeclaredPublicAssetFile[] = [];
+  const owners = new Map<string, number>();
+  const add = (index: number, logicalPath: string) => {
+    const owner = owners.get(logicalPath);
+    if (owner !== undefined) {
+      throw new Error(
+        `${scope.label}[${index}] and ${scope.label}[${owner}] both stage ${JSON.stringify(logicalPath)}.`,
+      );
+    }
+    owners.set(logicalPath, index);
+    files.push({ index, logicalPath });
+  };
+  const visit = async (
+    asset: DeclaredPublicAsset,
+    sourcePath: string,
+    destination: string,
+  ): Promise<void> => {
+    const stat = await fs.lstat(sourcePath);
+    if (stat.isSymbolicLink()) {
+      throw new Error(
+        `${scope.label}[${asset.index}].from must not contain symbolic links: ${path
+          .relative(appDirectory, sourcePath)
+          .replace(/\\/gu, '/')}`,
+      );
+    }
+    if (stat.isFile()) {
+      if (destination === DECLARED_PUBLIC_ASSET_DIRECTORY) {
+        throw new Error(
+          `${scope.label}[${asset.index}].to must name a file when ${scope.label}[${asset.index}].from is a file.`,
+        );
+      }
+      add(asset.index, destination);
+      return;
+    }
+    if (!stat.isDirectory()) {
+      throw new Error(
+        `${scope.label}[${asset.index}].from must contain only files and directories: ${path
+          .relative(appDirectory, sourcePath)
+          .replace(/\\/gu, '/')}`,
+      );
+    }
+    const entries = (await fs.readdir(sourcePath)).sort();
+    for (const entry of entries) {
+      await visit(
+        asset,
+        path.join(sourcePath, entry),
+        path.posix.join(destination, entry),
+      );
+    }
+  };
+
+  for (const asset of assets) {
+    const sourcePath = path.join(appDirectory, asset.from);
+    if (!(await pathExists(sourcePath))) {
+      throw new Error(
+        `${scope.label}[${asset.index}].from does not exist: ${asset.from}`,
+      );
+    }
+    await visit(
+      asset,
+      sourcePath,
+      path.posix.join(DECLARED_PUBLIC_ASSET_DIRECTORY, asset.to),
+    );
+  }
+  return files;
+};
+
+/**
+ * Resolve the files declared public assets add to a deploy output that was
+ * copied from `generatedRoot`, relative to the deploy output root. Declared
+ * files that replace a generated file are not part of the result, matching
+ * {@link stageDeclaredPublicAssets}.
+ */
+export const resolveAddedDeclaredPublicAssetPaths = async ({
+  appDirectory,
+  assets,
+  generatedRoot,
+  scope,
+}: {
+  appDirectory: string;
+  assets: readonly DeclaredPublicAsset[];
+  generatedRoot: string;
+  scope: DeclaredPublicAssetScope;
+}): Promise<string[]> => {
+  const added: string[] = [];
+  for (const file of await listDeclaredPublicAssetFiles(
+    appDirectory,
+    assets,
+    scope,
+  )) {
+    if (!(await pathExists(path.join(generatedRoot, file.logicalPath)))) {
+      added.push(file.logicalPath);
+    }
+  }
+  return added.sort();
+};
+
+/**
+ * Copy declared public assets into the deploy output after the framework has
+ * staged its own public files.
+ *
+ * A declared file may replace a generated public file, such as an app-owned
+ * `robots.txt`; the replaced file keeps its generated release classification.
+ *
+ * @returns the files the declarations added, relative to the deploy output
+ * root. The release envelope records these as declared public assets.
+ */
+export const stageDeclaredPublicAssets = async ({
+  appDirectory,
+  outputDirectory,
+  assets,
+  scope,
+}: {
+  appDirectory: string;
+  outputDirectory: string;
+  assets: readonly DeclaredPublicAsset[];
+  scope: DeclaredPublicAssetScope;
+}): Promise<string[]> => {
+  const files = await listDeclaredPublicAssetFiles(appDirectory, assets, scope);
+  const added: string[] = [];
+  for (const file of files) {
+    const asset = assets.find(candidate => candidate.index === file.index)!;
+    const relativePath = path.posix.relative(
+      path.posix.join(DECLARED_PUBLIC_ASSET_DIRECTORY, asset.to),
+      file.logicalPath,
+    );
+    const destination = path.join(outputDirectory, file.logicalPath);
+    const replacesGeneratedFile = await pathExists(destination);
+    await fs.mkdir(path.dirname(destination), { recursive: true });
+    await fs.copyFile(
+      path.join(appDirectory, asset.from, relativePath),
+      destination,
+    );
+    if (!replacesGeneratedFile) {
+      added.push(file.logicalPath);
+    }
+  }
+  return added.sort();
+};

package/src/deploy-output/target.ts

@@ -1,10 +1,19 @@
-import { provider } from 'std-env';
+import { getArgv } from '@modern-js/utils';
+import { provider as detectedProvider } from 'std-env';
 
-export interface DeployOutputConfig {
-  deploy?: { target?: string };
-}
+export const DEPLOY_TARGETS = [
+  'node',
+  'vercel',
+  'netlify',
+  'ghPages',
+  'cloudflare',
+] as const;
+
+export type DeployTarget = (typeof DEPLOY_TARGETS)[number];
 
-const providerDeployTargets: Partial<Record<string, string>> = {
+export const DEPLOY_TARGET_FLAG = '--deploy-target';
+
+const providerDeployTargets: Partial<Record<string, DeployTarget>> = {
   vercel: 'vercel',
   netlify: 'netlify',
   cloudflare: 'cloudflare',
@@ -12,12 +21,86 @@ const providerDeployTargets: Partial<Record<string, string>> = {
   cloudflare_workers: 'cloudflare',
 };
 
-export const resolveDeployTarget = (
-  config: DeployOutputConfig,
-  envDeployTarget = process.env.MODERNJS_DEPLOY,
-  detectedProvider = provider,
-): string =>
-  config.deploy?.target ||
-  envDeployTarget ||
-  (detectedProvider ? providerDeployTargets[detectedProvider] : undefined) ||
-  'node';
+export interface ResolvedDeployTarget {
+  target: DeployTarget;
+  /** The flag, `deploy.target` or `MODERNJS_DEPLOY` chose the target. */
+  explicit: boolean;
+}
+
+export interface ResolveDeployTargetOptions {
+  argv?: readonly string[];
+  configTarget?: string;
+  env?: string;
+  provider?: string;
+}
+
+const readDeployTargetFlag = (argv: readonly string[]) => {
+  for (const [index, arg] of argv.entries()) {
+    if (arg === DEPLOY_TARGET_FLAG) {
+      const value = argv[index + 1];
+      if (value === undefined || value.startsWith('-')) {
+        throw new Error(`${DEPLOY_TARGET_FLAG} needs a value.`);
+      }
+      return value;
+    }
+    if (arg.startsWith(`${DEPLOY_TARGET_FLAG}=`)) {
+      return arg.slice(DEPLOY_TARGET_FLAG.length + 1);
+    }
+  }
+  return undefined;
+};
+
+const assertDeployTarget = (target: string, source: string): DeployTarget => {
+  if (!(DEPLOY_TARGETS as readonly string[]).includes(target)) {
+    throw new Error(
+      `Unknown deploy target '${target}' from ${source}. Use one of: ${DEPLOY_TARGETS.join(', ')}.`,
+    );
+  }
+  return target as DeployTarget;
+};
+
+/**
+ * The one deploy-target resolver: `--deploy-target` > `deploy.target` >
+ * `MODERNJS_DEPLOY` > detected CI provider > `node`. app-tools stores the
+ * result in the app context once; config files that branch on the target call
+ * it without `configTarget`.
+ */
+export const resolveDeployTarget = ({
+  argv = getArgv(),
+  configTarget,
+  env = process.env.MODERNJS_DEPLOY,
+  provider = detectedProvider,
+}: ResolveDeployTargetOptions = {}): ResolvedDeployTarget => {
+  const explicit = (
+    [
+      [readDeployTargetFlag(argv), DEPLOY_TARGET_FLAG],
+      [configTarget, 'deploy.target'],
+      [env, 'MODERNJS_DEPLOY'],
+    ] as const
+  ).find(([target]) => target);
+  if (explicit?.[0]) {
+    return {
+      target: assertDeployTarget(explicit[0], explicit[1]),
+      explicit: true,
+    };
+  }
+  return {
+    target: (provider && providerDeployTargets[provider]) || 'node',
+    explicit: false,
+  };
+};
+
+/**
+ * The target `modern deploy` stages. Apps under another CLI meta name deploy
+ * only when a flag, config or env chose the target explicitly.
+ */
+export const getDeployingTarget = ({
+  deployTarget,
+  metaName,
+}: {
+  deployTarget?: ResolvedDeployTarget;
+  metaName: string;
+}): DeployTarget | undefined =>
+  deployTarget && (metaName === 'modern-js' || deployTarget.explicit)
+    ? deployTarget.target
+    : undefined;

package/src/deploy-output/trace-files.ts

@@ -0,0 +1,80 @@
+import os from 'node:os';
+import path from 'node:path';
+import type { NodeFileTraceResult } from '@vercel/nft';
+
+// Directories owned by the build host rather than the app. nft statically
+// evaluates `os.homedir()`, `os.tmpdir()` and literal system paths, so code
+// like `fs.readFileSync(path.join(os.homedir(), name))` becomes a glob of the
+// whole home directory. With `base: '/'` that glob walks the machine.
+const SYSTEM_ROOTS =
+  process.platform === 'win32'
+    ? []
+    : ['/dev', '/etc', '/proc', '/run', '/sys', '/var/run'];
+
+const GLOB_SEGMENT = /[*?[{]/;
+
+const isInside = (parent: string, child: string) =>
+  child === parent || child.startsWith(`${parent}${path.sep}`);
+
+const globRoot = (absolutePattern: string) => {
+  const { root } = path.parse(absolutePattern);
+  const segments = absolutePattern.slice(root.length).split(path.sep);
+  const index = segments.findIndex(segment => GLOB_SEGMENT.test(segment));
+  return index === -1
+    ? undefined
+    : path.join(root, ...segments.slice(0, index));
+};
+
+/**
+ * Builds the nft `ignore` predicate for a trace rooted at `base`: skip every
+ * path under a system root, and skip globs that would enumerate the file
+ * system root, the home directory or the temp directory as a whole. Files
+ * inside home or temp are still traced, since package stores can live there.
+ */
+export const createBuildHostIgnore = (base: string) => {
+  const wholeDirectories = new Set([
+    path.parse(path.resolve(base)).root,
+    path.resolve(os.homedir()),
+    path.resolve(os.tmpdir()),
+  ]);
+  return (relativePath: string) => {
+    const absolutePath = path.resolve(base, relativePath);
+    if (SYSTEM_ROOTS.some(root => isInside(root, absolutePath))) {
+      return true;
+    }
+    const root = globRoot(absolutePath);
+    return root !== undefined && wholeDirectories.has(root);
+  };
+};
+
+/**
+ * `traceFiles` implementation for ndepe's `nodeDepEmit`, tracing with the
+ * `@vercel/nft` release app-tools-extensions depends on instead of the one ndepe pins.
+ */
+export const traceDeployFiles = ({
+  entryFiles,
+  sourceDir,
+  base = '/',
+}: {
+  entryFiles: string[];
+  sourceDir: string;
+  base?: string;
+}): Promise<NodeFileTraceResult> => {
+  const resolvedBase = path.resolve(base);
+  const ignore = createBuildHostIgnore(resolvedBase);
+  try {
+    // NFT resolves roots and maps entries before its first await. Capture the
+    // same invocation here so loading it cannot observe a later cwd or edit.
+    const options = {
+      base: resolvedBase,
+      processCwd: path.resolve(sourceDir || resolvedBase),
+      ignore,
+    };
+    const entries = entryFiles.map(file => path.resolve(file));
+    return import('@vercel/nft').then(({ nodeFileTrace }) =>
+      nodeFileTrace(entries, options),
+    );
+  } catch (error) {
+    return Promise.reject(error);
+  }
+};