@soundscript/soundscript 0.1.13 → 0.1.15

package/project-transform/src/build_package.ts

@@ -0,0 +1,683 @@
+import { dirname, extname, join, relative } from './platform/path.ts';
+import ts from 'typescript';
+
+import { createSoundStdlibCompilerHost } from './bundled/sound_stdlib.ts';
+import {
+  formatDiagnostics,
+  hasErrorDiagnostics,
+  type MergedDiagnostic,
+  toMergedDiagnostic,
+} from './checker/diagnostics.ts';
+import { analyzeProject } from './checker/analyze_project.ts';
+import {
+  collectSoundscriptRootNames,
+  getConfigFileParsingDiagnostics,
+  loadConfig,
+  type RuntimeTarget,
+} from './config.ts';
+import { createBuiltinExpandedProgram } from './frontend/builtin_macro_support.ts';
+import { MacroError } from './frontend/macro_errors.ts';
+import {
+  emitProjectedDeclarations,
+  isSoundscriptSourceFile,
+  toSourceFileName,
+} from './frontend/project_frontend.ts';
+import { loadSoundScriptPackageInfo, type SoundScriptPackageInfo } from './soundscript_packages.ts';
+import {
+  copyFile,
+  fileExistsSync,
+  makeDirectory,
+  readTextFileSync,
+  removePath,
+  writeTextFile,
+} from './platform/host.ts';
+import {
+  rewriteModuleSpecifiersForEmit,
+  transpilePreparedSoundscriptModuleToEsm,
+  transpileTypeScriptModuleToEsm,
+} from './runtime/transform.ts';
+import { SOUNDSCRIPT_RUNTIME_PACKAGE_NAME } from './soundscript_runtime_specifiers.ts';
+
+const DECLARATION_CAPTURE_OUT_DIR = '/__soundscript_build_types__';
+
+export interface BuildProjectOptions {
+  outDir: string;
+  projectPath: string;
+  target?: RuntimeTarget;
+  workingDirectory: string;
+}
+
+export interface BuildProjectArtifacts {
+  emittedFiles: string[];
+  outDir: string;
+  packageJsonPath: string;
+}
+
+export interface BuildProjectResult {
+  artifacts?: BuildProjectArtifacts;
+  diagnostics: MergedDiagnostic[];
+  exitCode: number;
+  output: string;
+}
+
+interface PackageJsonRecord extends Record<string, unknown> {
+  bugs?: unknown;
+  homepage?: unknown;
+  license?: unknown;
+  name?: unknown;
+  repository?: unknown;
+  version?: unknown;
+}
+
+interface SoundscriptMetadataRecord extends Record<string, unknown> {
+  exports?: unknown;
+}
+
+function createMacroDiagnostic(error: MacroError): MergedDiagnostic {
+  return {
+    source: 'cli',
+    code: error.code,
+    category: 'error',
+    message: error.message,
+    filePath: error.filePath,
+    line: error.line,
+    column: error.column,
+    endLine: error.endLine,
+    endColumn: error.endColumn,
+  };
+}
+
+function isPackageLocalSourceFile(fileName: string, packageRoot: string): boolean {
+  return fileName.startsWith(`${packageRoot}/`) &&
+    !fileName.endsWith('.d.ts') &&
+    !fileName.includes('/node_modules/');
+}
+
+function toJsRelativePath(relativePath: string): string {
+  const extension = extname(relativePath);
+  return extension.length > 0
+    ? `${relativePath.slice(0, -extension.length)}.js`
+    : `${relativePath}.js`;
+}
+
+function toDeclarationRelativePath(relativePath: string): string {
+  const extension = extname(relativePath);
+  return extension.length > 0
+    ? `${relativePath.slice(0, -extension.length)}.d.ts`
+    : `${relativePath}.d.ts`;
+}
+
+function toEntryWrapperRelativePath(exportKey: string): string {
+  return exportKey === '.' ? 'index' : exportKey.slice(2);
+}
+
+function renderBuildOutput(artifacts: BuildProjectArtifacts, projectPath: string): string {
+  const artifactBaseDirectory = dirname(projectPath);
+  const renderedFiles = artifacts.emittedFiles
+    .map((filePath) => `  ${relative(artifactBaseDirectory, filePath)}`)
+    .join('\n');
+
+  return [
+    `Built package: ${relative(artifactBaseDirectory, artifacts.outDir)}`,
+    renderedFiles,
+    '',
+  ].join('\n');
+}
+
+function findNearestPackageJson(startDirectory: string): string | undefined {
+  let currentDirectory = startDirectory;
+  while (true) {
+    const candidate = join(currentDirectory, 'package.json');
+    if (fileExistsSync(candidate)) {
+      return candidate;
+    }
+
+    const parentDirectory = dirname(currentDirectory);
+    if (parentDirectory === currentDirectory) {
+      return undefined;
+    }
+    currentDirectory = parentDirectory;
+  }
+}
+
+async function emptyDirectory(path: string): Promise<void> {
+  await removePath(path).catch(() => undefined);
+  await makeDirectory(path);
+}
+
+async function copyFileIfPresent(sourcePath: string, destinationPath: string): Promise<boolean> {
+  if (!fileExistsSync(sourcePath)) {
+    return false;
+  }
+
+  await makeDirectory(dirname(destinationPath));
+  await copyFile(sourcePath, destinationPath);
+  return true;
+}
+
+function relativeImportSpecifier(fromFilePath: string, toFilePath: string): string {
+  const relativePath = relative(dirname(fromFilePath), toFilePath).replaceAll('\\', '/');
+  return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}
+
+function relativeTypeImportSpecifier(fromFilePath: string, toDeclarationPath: string): string {
+  const specifier = relativeImportSpecifier(fromFilePath, toDeclarationPath);
+  return specifier.endsWith('.d.ts') ? specifier.slice(0, -5) : specifier;
+}
+
+function moduleHasDefaultExport(program: ts.Program, programFileName: string): boolean {
+  const sourceFile = program.getSourceFile(programFileName);
+  if (!sourceFile) {
+    return false;
+  }
+
+  const checker = program.getTypeChecker();
+  const symbol = checker.getSymbolAtLocation(sourceFile);
+  if (!symbol) {
+    return false;
+  }
+
+  return checker.getExportsOfModule(symbol).some((exportSymbol) => exportSymbol.name === 'default');
+}
+
+function createEntryWrapperText(importSpecifier: string, hasDefaultExport: boolean): string {
+  const lines = [`export * from '${importSpecifier}';`];
+  if (hasDefaultExport) {
+    lines.push(`export { default } from '${importSpecifier}';`);
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+function createPackageBuildProgram(options: BuildProjectOptions) {
+  const loadedConfig = loadConfig(options.projectPath, { target: options.target });
+  const soundscriptRootNames = collectSoundscriptRootNames(options.projectPath, loadedConfig);
+  return createBuiltinExpandedProgram({
+    baseHost: createSoundStdlibCompilerHost(
+      loadedConfig.commandLine.options,
+      dirname(options.projectPath),
+    ),
+    configFileParsingDiagnostics: getConfigFileParsingDiagnostics(
+      loadedConfig.diagnostics,
+      soundscriptRootNames,
+    ),
+    options: {
+      ...loadedConfig.commandLine.options,
+      declaration: true,
+      emitDeclarationOnly: true,
+      noEmit: false,
+      outDir: DECLARATION_CAPTURE_OUT_DIR,
+      sourceMap: true,
+    },
+    projectReferences: loadedConfig.commandLine.projectReferences,
+    runtime: loadedConfig.runtime,
+    rootNames: [...new Set([...loadedConfig.commandLine.fileNames, ...soundscriptRootNames])],
+  });
+}
+
+function captureTypeScriptDeclarationOutputs(program: ts.Program): ReadonlyMap<string, string> {
+  const outputs = new Map<string, string>();
+  program.emit(
+    undefined,
+    (fileName, text) => {
+      outputs.set(fileName, text);
+    },
+    undefined,
+    true,
+  );
+  return outputs;
+}
+
+async function writeGeneratedFile(
+  filePath: string,
+  text: string,
+  emittedFiles: string[],
+): Promise<void> {
+  await makeDirectory(dirname(filePath));
+  await writeTextFile(filePath, text);
+  emittedFiles.push(filePath);
+}
+
+function parsePackageJsonRecord(packageJsonPath: string): PackageJsonRecord {
+  return JSON.parse(readTextFileSync(packageJsonPath)) as PackageJsonRecord;
+}
+
+function collectInvalidSoundscriptExportDiagnostics(
+  packageJsonPath: string,
+  packageJson: PackageJsonRecord,
+  packageInfo: SoundScriptPackageInfo | undefined,
+): MergedDiagnostic[] {
+  const soundscript = packageJson.soundscript;
+  if (!soundscript || typeof soundscript !== 'object' || Array.isArray(soundscript)) {
+    return [];
+  }
+
+  const metadata = soundscript as SoundscriptMetadataRecord;
+  if (
+    !metadata.exports || typeof metadata.exports !== 'object' || Array.isArray(metadata.exports)
+  ) {
+    return [];
+  }
+
+  const diagnostics: MergedDiagnostic[] = [];
+  const declaredExports = metadata.exports as Record<string, unknown>;
+  for (const [exportKey, rawEntry] of Object.entries(declaredExports)) {
+    if (!rawEntry || typeof rawEntry !== 'object' || Array.isArray(rawEntry)) {
+      diagnostics.push({
+        source: 'cli',
+        code: 'SOUNDSCRIPT_BUILD_INVALID_EXPORT',
+        category: 'error',
+        message:
+          `soundscript.exports["${exportKey}"] must be an object with a valid "source" path.`,
+        hint:
+          'Use an object with a `source` field that points at an existing `.sts` file in the published package surface.',
+        filePath: packageJsonPath,
+        line: 1,
+        column: 1,
+        endLine: 1,
+        endColumn: 1,
+      });
+      continue;
+    }
+
+    const source = (rawEntry as Record<string, unknown>).source;
+    if (typeof source !== 'string' || source.length === 0) {
+      diagnostics.push({
+        source: 'cli',
+        code: 'SOUNDSCRIPT_BUILD_INVALID_EXPORT',
+        category: 'error',
+        message: `soundscript.exports["${exportKey}"] must provide a string "source" path.`,
+        hint:
+          'Use an object with a `source` field that points at an existing `.sts` file in the published package surface.',
+        filePath: packageJsonPath,
+        line: 1,
+        column: 1,
+        endLine: 1,
+        endColumn: 1,
+      });
+      continue;
+    }
+
+    if (!packageInfo?.exports.has(exportKey)) {
+      diagnostics.push({
+        source: 'cli',
+        code: 'SOUNDSCRIPT_BUILD_INVALID_EXPORT',
+        category: 'error',
+        message: `soundscript.exports["${exportKey}"] points to a missing source file: ${source}`,
+        hint:
+          'Point each `soundscript.exports` entry at an existing `.sts` file that belongs to the published package surface.',
+        filePath: packageJsonPath,
+        line: 1,
+        column: 1,
+        endLine: 1,
+        endColumn: 1,
+      });
+    }
+  }
+
+  return diagnostics;
+}
+
+function buildDistPackageJson(
+  originalPackageJson: PackageJsonRecord,
+  packageInfo: SoundScriptPackageInfo,
+): Record<string, unknown> {
+  const exportsRecord: Record<string, unknown> = {};
+  const soundscriptExports: Record<string, unknown> = {};
+
+  for (const [exportKey, sourceEntryPath] of packageInfo.exports.entries()) {
+    const relativeSourcePath = relative(packageInfo.packageRoot, sourceEntryPath).replaceAll(
+      '\\',
+      '/',
+    );
+    const wrapperRelativePath = toEntryWrapperRelativePath(exportKey);
+    exportsRecord[exportKey] = {
+      import: `./esm/${wrapperRelativePath}.js`,
+      types: `./types/${wrapperRelativePath}.d.ts`,
+    };
+    soundscriptExports[exportKey] = {
+      source: `./soundscript/${relativeSourcePath}`,
+    };
+  }
+
+  if (packageInfo.legacySourceEntryPath && !packageInfo.exports.has('.')) {
+    const relativeSourcePath = relative(packageInfo.packageRoot, packageInfo.legacySourceEntryPath)
+      .replaceAll('\\', '/');
+    exportsRecord['.'] = {
+      import: './esm/index.js',
+      types: './types/index.d.ts',
+    };
+    soundscriptExports['.'] = {
+      source: `./soundscript/${relativeSourcePath}`,
+    };
+  }
+
+  const files = ['esm/**', 'types/**', 'soundscript/**'];
+  if (fileExistsSync(join(dirname(packageInfo.packageJsonPath), 'README.md'))) {
+    files.unshift('README.md');
+  }
+  if (fileExistsSync(join(dirname(packageInfo.packageJsonPath), 'LICENSE'))) {
+    files.unshift('LICENSE');
+  }
+
+  return {
+    ...(typeof originalPackageJson.name === 'string' ? { name: originalPackageJson.name } : {}),
+    ...(typeof originalPackageJson.version === 'string'
+      ? { version: originalPackageJson.version }
+      : {}),
+    ...(typeof originalPackageJson.license === 'string'
+      ? { license: originalPackageJson.license }
+      : {}),
+    type: 'module',
+    ...(typeof originalPackageJson.repository === 'object'
+      ? { repository: originalPackageJson.repository }
+      : {}),
+    ...(typeof originalPackageJson.homepage === 'string'
+      ? { homepage: originalPackageJson.homepage }
+      : {}),
+    ...(typeof originalPackageJson.bugs === 'object' ? { bugs: originalPackageJson.bugs } : {}),
+    ...(exportsRecord['.'] ? { types: './types/index.d.ts' } : {}),
+    exports: exportsRecord,
+    files,
+    ...(packageInfo.name === SOUNDSCRIPT_RUNTIME_PACKAGE_NAME ? {} : packageInfo.toolchain
+      ? {
+        peerDependencies: {
+          [SOUNDSCRIPT_RUNTIME_PACKAGE_NAME]: packageInfo.toolchain,
+        },
+      }
+      : {}),
+    soundscript: {
+      ...(packageInfo.version !== undefined ? { version: packageInfo.version } : {}),
+      ...(packageInfo.toolchain ? { toolchain: packageInfo.toolchain } : {}),
+      exports: soundscriptExports,
+    },
+  };
+}
+
+export async function buildProject(options: BuildProjectOptions): Promise<BuildProjectResult> {
+  const packageJsonPath = findNearestPackageJson(dirname(options.projectPath));
+  if (!packageJsonPath) {
+    const diagnostics: MergedDiagnostic[] = [{
+      source: 'cli',
+      code: 'SOUNDSCRIPT_BUILD_NO_PACKAGE_JSON',
+      category: 'error',
+      message: 'Could not find a package.json for soundscript build.',
+      hint:
+        'Add a package.json in the package root before running `soundscript build`, or use `soundscript check` for local app-only workflows.',
+      filePath: options.projectPath,
+      line: 1,
+      column: 1,
+      endLine: 1,
+      endColumn: 1,
+    }];
+    return {
+      diagnostics,
+      exitCode: 1,
+      output: formatDiagnostics(diagnostics, options.workingDirectory),
+    };
+  }
+
+  const packageJson = parsePackageJsonRecord(packageJsonPath);
+  const packageInfo = loadSoundScriptPackageInfo(packageJsonPath, ts.sys);
+  const invalidExportDiagnostics = collectInvalidSoundscriptExportDiagnostics(
+    packageJsonPath,
+    packageJson,
+    packageInfo,
+  );
+  if (invalidExportDiagnostics.length > 0) {
+    return {
+      diagnostics: invalidExportDiagnostics,
+      exitCode: 1,
+      output: formatDiagnostics(invalidExportDiagnostics, options.workingDirectory),
+    };
+  }
+  if (!packageInfo || (packageInfo.exports.size === 0 && !packageInfo.legacySourceEntryPath)) {
+    const diagnostics: MergedDiagnostic[] = [{
+      source: 'cli',
+      code: 'SOUNDSCRIPT_BUILD_NO_EXPORTS',
+      category: 'error',
+      message: 'package.json is missing soundscript.exports metadata for soundscript build.',
+      hint:
+        'Add `package.json#soundscript.exports` entries for the published `.sts` surface, or use `soundscript check` / runtime wrappers for local app workflows.',
+      filePath: packageJsonPath,
+      line: 1,
+      column: 1,
+      endLine: 1,
+      endColumn: 1,
+    }];
+    return {
+      diagnostics,
+      exitCode: 1,
+      output: formatDiagnostics(diagnostics, options.workingDirectory),
+    };
+  }
+
+  const analysis = analyzeProject({
+    projectPath: options.projectPath,
+    target: options.target,
+    workingDirectory: options.workingDirectory,
+  });
+  if (hasErrorDiagnostics(analysis.diagnostics)) {
+    return {
+      diagnostics: analysis.diagnostics,
+      exitCode: 1,
+      output: formatDiagnostics(analysis.diagnostics, options.workingDirectory),
+    };
+  }
+
+  const builtProgram = createPackageBuildProgram(options);
+  try {
+    const diagnostics: MergedDiagnostic[] = [
+      ...builtProgram.frontendDiagnostics(),
+      ...ts.getPreEmitDiagnostics(builtProgram.program).map(toMergedDiagnostic),
+    ];
+    if (hasErrorDiagnostics(diagnostics)) {
+      return {
+        diagnostics,
+        exitCode: 1,
+        output: formatDiagnostics(diagnostics, options.workingDirectory),
+      };
+    }
+
+    try {
+      void builtProgram.program.getTypeChecker();
+    } catch (error) {
+      const merged = error instanceof MacroError ? [createMacroDiagnostic(error)] : [];
+      return {
+        diagnostics: merged,
+        exitCode: 1,
+        output: error instanceof MacroError
+          ? formatDiagnostics(merged, options.workingDirectory)
+          : String(error),
+      };
+    }
+
+    await emptyDirectory(options.outDir);
+    const emittedFiles: string[] = [];
+    const typeOutputs = captureTypeScriptDeclarationOutputs(builtProgram.program);
+    const projectedDeclarations = emitProjectedDeclarations(builtProgram.analysisPreparedProgram);
+    const packageRoot = packageInfo.packageRoot;
+
+    for (const sourceFile of builtProgram.program.getSourceFiles()) {
+      if (sourceFile.isDeclarationFile) {
+        continue;
+      }
+
+      const sourceFileName = toSourceFileName(sourceFile.fileName);
+      if (!isPackageLocalSourceFile(sourceFileName, packageRoot)) {
+        continue;
+      }
+
+      const relativeSourcePath = relative(packageRoot, sourceFileName).replaceAll('\\', '/');
+      const outputJsRelativePath = toJsRelativePath(relativeSourcePath);
+      const outputJsPath = join(options.outDir, 'esm', outputJsRelativePath);
+      const outputMapPath = `${outputJsPath}.map`;
+      const sourceMapComment = `//# sourceMappingURL=${
+        relative(dirname(outputJsPath), outputMapPath).replaceAll('\\', '/')
+      }`;
+
+      const artifact = isSoundscriptSourceFile(sourceFileName)
+        ? (() => {
+          const preparedFile = builtProgram.diagnosticPreparedFiles.get(sourceFileName) ??
+            builtProgram.analysisPreparedProgram.preparedHost.getPreparedSourceFile(
+              sourceFileName,
+            );
+          if (!preparedFile) {
+            throw new Error(`Missing prepared source file for ${sourceFileName}.`);
+          }
+          return transpilePreparedSoundscriptModuleToEsm(
+            sourceFileName,
+            outputJsPath,
+            preparedFile,
+            {
+              module: ts.ModuleKind.ES2022,
+              target: ts.ScriptTarget.ES2022,
+              valueProgram: builtProgram.program,
+            },
+          );
+        })()
+        : transpileTypeScriptModuleToEsm(
+          sourceFileName,
+          outputJsPath,
+          sourceFile.text,
+          {
+            module: ts.ModuleKind.ES2022,
+            target: ts.ScriptTarget.ES2022,
+          },
+        );
+
+      await writeGeneratedFile(
+        outputJsPath,
+        `${artifact.code}\n${sourceMapComment}\n`,
+        emittedFiles,
+      );
+      await writeGeneratedFile(outputMapPath, artifact.mapText, emittedFiles);
+    }
+
+    for (const [sourceFileName, declarationText] of projectedDeclarations.entries()) {
+      if (!isPackageLocalSourceFile(sourceFileName, packageRoot)) {
+        continue;
+      }
+
+      const relativeSourcePath = relative(packageRoot, sourceFileName).replaceAll('\\', '/');
+      const declarationPath = join(
+        options.outDir,
+        'types',
+        toDeclarationRelativePath(relativeSourcePath),
+      );
+      await writeGeneratedFile(
+        declarationPath,
+        rewriteModuleSpecifiersForEmit(declarationText, declarationPath),
+        emittedFiles,
+      );
+    }
+
+    for (const [outputPath, declarationText] of typeOutputs.entries()) {
+      if (
+        !outputPath.startsWith(`${DECLARATION_CAPTURE_OUT_DIR}/`) ||
+        outputPath.endsWith('.sts.d.ts')
+      ) {
+        continue;
+      }
+
+      const relativeOutputPath = relative(DECLARATION_CAPTURE_OUT_DIR, outputPath).replaceAll(
+        '\\',
+        '/',
+      );
+      const destinationPath = join(options.outDir, 'types', relativeOutputPath);
+      await writeGeneratedFile(
+        destinationPath,
+        rewriteModuleSpecifiersForEmit(declarationText, destinationPath),
+        emittedFiles,
+      );
+    }
+
+    const copiedSourceFiles = new Set<string>();
+    for (const sourceFile of builtProgram.program.getSourceFiles()) {
+      if (sourceFile.isDeclarationFile) {
+        continue;
+      }
+
+      const sourceFileName = toSourceFileName(sourceFile.fileName);
+      if (
+        !isPackageLocalSourceFile(sourceFileName, packageRoot) ||
+        copiedSourceFiles.has(sourceFileName)
+      ) {
+        continue;
+      }
+      copiedSourceFiles.add(sourceFileName);
+
+      const relativeSourcePath = relative(packageRoot, sourceFileName).replaceAll('\\', '/');
+      const destinationPath = join(options.outDir, 'soundscript', relativeSourcePath);
+      await makeDirectory(dirname(destinationPath));
+      await copyFile(sourceFileName, destinationPath);
+      emittedFiles.push(destinationPath);
+    }
+
+    const sourceEntries = packageInfo.exports.size > 0
+      ? [...packageInfo.exports.entries()]
+      : packageInfo.legacySourceEntryPath
+      ? [['.', packageInfo.legacySourceEntryPath] as const]
+      : [];
+    for (const [exportKey, sourceEntryPath] of sourceEntries) {
+      const relativeSourcePath = relative(packageRoot, sourceEntryPath).replaceAll('\\', '/');
+      const wrapperRelativePath = toEntryWrapperRelativePath(exportKey);
+      const sourceJsPath = join(options.outDir, 'esm', toJsRelativePath(relativeSourcePath));
+      const wrapperJsPath = join(options.outDir, 'esm', `${wrapperRelativePath}.js`);
+      const wrapperTypesPath = join(options.outDir, 'types', `${wrapperRelativePath}.d.ts`);
+      const programFileName = isSoundscriptSourceFile(sourceEntryPath)
+        ? builtProgram.preparedProgram.toProgramFileName(sourceEntryPath)
+        : sourceEntryPath;
+      const hasDefaultExport = moduleHasDefaultExport(builtProgram.program, programFileName);
+      const jsImportSpecifier = relativeImportSpecifier(wrapperJsPath, sourceJsPath);
+      const typesImportSpecifier = relativeTypeImportSpecifier(
+        wrapperTypesPath,
+        join(options.outDir, 'types', toDeclarationRelativePath(relativeSourcePath)),
+      );
+      await writeGeneratedFile(
+        wrapperJsPath,
+        createEntryWrapperText(jsImportSpecifier, hasDefaultExport),
+        emittedFiles,
+      );
+      await writeGeneratedFile(
+        wrapperTypesPath,
+        createEntryWrapperText(typesImportSpecifier, hasDefaultExport),
+        emittedFiles,
+      );
+    }
+
+    await copyFileIfPresent(join(packageRoot, 'README.md'), join(options.outDir, 'README.md'));
+    await copyFileIfPresent(join(packageRoot, 'LICENSE'), join(options.outDir, 'LICENSE'));
+
+    const distPackageJson = buildDistPackageJson(
+      packageJson,
+      packageInfo,
+    );
+    const distPackageJsonPath = join(options.outDir, 'package.json');
+    await writeGeneratedFile(
+      distPackageJsonPath,
+      `${JSON.stringify(distPackageJson, null, 2)}\n`,
+      emittedFiles,
+    );
+
+    return {
+      artifacts: {
+        emittedFiles,
+        outDir: options.outDir,
+        packageJsonPath: distPackageJsonPath,
+      },
+      diagnostics: [],
+      exitCode: 0,
+      output: renderBuildOutput(
+        {
+          emittedFiles,
+          outDir: options.outDir,
+          packageJsonPath: distPackageJsonPath,
+        },
+        options.projectPath,
+      ),
+    };
+  } finally {
+    builtProgram.dispose();
+  }
+}