@plugjs/tsgo 0.0.6 → 0.1.0

package/dist/utils.js

@@ -0,0 +1,58 @@
+import { assert } from '@plugjs/plug/asserts';
+import { resolveFile } from '@plugjs/plug/paths';
+import { EmitOnly } from 'typescript/unstable/async';
+/**
+ * Find the TypeScript project configuration file for a given path.
+ *
+ * The path specified can be a `tsconfig.json` file name or a directory
+ * containing a `tsconfig.json` file.
+ *
+ * The returned path is the absolute path of the actual `tsconfig.json` file.
+ */
+export function findProjectConfig(path) {
+    // The specified path can be either a file or a directory containing a
+    // "tsconfig.json" file: resolve as a file, then assume it's a directory
+    let file = resolveFile(path);
+    if (!file)
+        file = resolveFile(path, 'tsconfig.json');
+    assert(file, `TypeScript configuration file not found in "${path}"`);
+    return file;
+}
+/** Convert a diagnostic level option for deprecations into a consistent value. */
+export function diagnosticDeprecationLevel(deprecations) {
+    switch (deprecations) {
+        // If *warn* we report deprecations as warnings
+        case 'warn':
+            return 'warn';
+        // If *off* or *false* we don't report deprecations at all
+        case 'off':
+        case false:
+            return 'off';
+        // If *notice* or *true* (default) we report deprecations as notices
+        /* coverage ignore next */ case 'notice':
+        /* coverage ignore next */ case true:
+        default:
+            return 'notice';
+    }
+}
+/** Convert a emit only option into its corresponding enum value. */
+export function emitOnlyOption(emitOnly) {
+    switch (emitOnly) {
+        // If *none* or *false* we don't emit anything
+        case 'none':
+        case false:
+            return null; // This is "none"
+        // If *js* we only emit JavaScript files
+        case 'js':
+            return EmitOnly.OnlyJs;
+        // If *dts* we only emit declaration files
+        case 'dts':
+            return EmitOnly.OnlyDts;
+        // In all other cases we emit all files
+        /* coverage ignore next */ case 'all':
+        /* coverage ignore next */ case true:
+        default:
+            return EmitOnly.All;
+    }
+}
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AAKpD;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAkB;IAClD,sEAAsE;IACtE,wEAAwE;IACxE,IAAI,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,CAAA;IAC5B,IAAI,CAAC,IAAI;QAAE,IAAI,GAAG,WAAW,CAAC,IAAI,EAAE,eAAe,CAAC,CAAA;IACpD,MAAM,CAAC,IAAI,EAAE,+CAA+C,IAAI,GAAG,CAAC,CAAA;IACpE,OAAO,IAAI,CAAA;AACb,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,0BAA0B,CACxC,YAAsD;IAEtD,QAAQ,YAAY,EAAE,CAAC;QACrB,+CAA+C;QAC/C,KAAK,MAAM;YACT,OAAO,MAAM,CAAA;QACf,0DAA0D;QAC1D,KAAK,KAAK,CAAC;QACX,KAAK,KAAK;YACR,OAAO,KAAK,CAAA;QACd,oEAAoE;QACpE,0BAA0B,CAAC,KAAK,QAAQ,CAAC;QACzC,0BAA0B,CAAC,KAAK,IAAI,CAAC;QACrC;YACE,OAAO,QAAQ,CAAA;IACnB,CAAC;AACH,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,cAAc,CAAC,QAAwC;IACrE,QAAQ,QAAQ,EAAE,CAAC;QACjB,8CAA8C;QAC9C,KAAK,MAAM,CAAC;QACZ,KAAK,KAAK;YACR,OAAO,IAAI,CAAA,CAAC,iBAAiB;QAC/B,wCAAwC;QACxC,KAAK,IAAI;YACP,OAAO,QAAQ,CAAC,MAAM,CAAA;QACxB,0CAA0C;QAC1C,KAAK,KAAK;YACR,OAAO,QAAQ,CAAC,OAAO,CAAA;QACzB,uCAAuC;QACvC,0BAA0B,CAAC,KAAK,KAAK,CAAC;QACtC,0BAA0B,CAAC,KAAK,IAAI,CAAC;QACrC;YACE,OAAO,QAAQ,CAAC,GAAG,CAAA;IACvB,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plugjs/tsgo",
-  "version": "0.0.6",
+  "version": "0.1.0",
   "description": "TypeScript 7.1 support for PlugJS",
   "keywords": [
     "build",
@@ -55,12 +55,12 @@
     "typescript": "^7.1.0-dev"
   },
   "devDependencies": {
-    "@plugjs/cov8": "^0.7.8",
-    "@plugjs/expect5": "^0.7.8",
-    "@plugjs/oxc": "^0.1.9",
-    "@plugjs/plug": "^0.7.8"
+    "@plugjs/cov8": "^0.7.11",
+    "@plugjs/expect5": "^0.7.11",
+    "@plugjs/oxc": "^0.1.13",
+    "@plugjs/plug": "^0.7.11"
   },
   "peerDependencies": {
-    "@plugjs/plug": "^0.7.8"
+    "@plugjs/plug": "^0.7.11"
   }
 }

package/src/diagnostics.ts

@@ -3,11 +3,9 @@ import { assertAbsolutePath } from '@plugjs/plug/paths'
 import { DiagnosticCategory } from 'typescript/unstable/async'
 
 import type { ReportRecord } from '@plugjs/plug/logging'
-import type { AbsolutePath } from '@plugjs/plug/paths'
-import type { SourceFile } from 'typescript/unstable/ast'
-import type { Diagnostic, Program } from 'typescript/unstable/async'
+import type { Diagnostic } from 'typescript/unstable/async'
 
-function convertDiagnostic(diagnostic: Diagnostic, sourceFile?: SourceFile): ReportRecord {
+function convertDiagnostic(diagnostic: Diagnostic): ReportRecord {
   const record: ReportRecord & { tags: string[] } = {
     level: NOTICE,
     message: diagnostic.text,
@@ -31,22 +29,21 @@ function convertDiagnostic(diagnostic: Diagnostic, sourceFile?: SourceFile): Rep
     record.file = diagnostic.fileName
   }
 
-  if (sourceFile) {
-    const pos = sourceFile.getLineAndCharacterOfPosition(diagnostic.pos)
+  if (diagnostic.startPosition) {
+    const pos = diagnostic.startPosition
     record.line = pos.line + 1
     record.column = pos.character + 1
     record.length = diagnostic.end - diagnostic.pos
-    record.source = sourceFile.getFullText()
+    record.source = diagnostic.source
   }
 
   return record
 }
 
-export async function convertDiagnostics(
+export function convertDiagnostics(
   diagnostics: readonly Diagnostic[],
-  program: Program,
   deprecations: 'warn' | 'notice' | 'off' = 'notice',
-): Promise<ReportRecord[]> {
+): ReportRecord[] {
   // Filter out any duplicate diagnostic *before* we convert them to report
   // records (that might be expensive because of source file lookups)
   const seen = new Set<string>()
@@ -65,59 +62,23 @@ export async function convertDiagnostics(
   })
 
   // Convert all diagnostics to report records
-  const converted = await Promise.all(
-    unique.map(async (diagnostic) => {
-      // Anything not an error is not critical
-      const isNonCritical = diagnostic.category !== DiagnosticCategory.Error
-
-      // First of all see how we need to handle non-error deprecations: when
-      // "off" we suppress them, when "warn" we convert them to warnings...
-      if (diagnostic.reportsDeprecated && isNonCritical) {
-        if (deprecations === 'off') return // simply filter this out...
-        if (deprecations === 'warn') {
-          diagnostic = { ...diagnostic, category: DiagnosticCategory.Warning }
-        }
+  const converted = unique.map((diagnostic) => {
+    // Anything not an error is not critical
+    const isNonCritical = diagnostic.category !== DiagnosticCategory.Error
+
+    // First of all see how we need to handle non-error deprecations: when
+    // "off" we suppress them, when "warn" we convert them to warnings...
+    if (diagnostic.reportsDeprecated && isNonCritical) {
+      if (deprecations === 'off') return // simply filter this out...
+      if (deprecations === 'warn') {
+        diagnostic = { ...diagnostic, category: DiagnosticCategory.Warning }
       }
+    }
 
-      // First figure out where this diagnostic came from...
-      const sourceFileMetadata = diagnostic.fileName
-        ? await program.getSourceFileMetadata(diagnostic.fileName)
-        : /* coverage ignore next */ undefined
-
-      // If the source file is in the default library (e.g. "lib.dom.ts") or
-      // from an external library (in "node_modules") then we ONLY keep errors
-      // and (we ignore things like warnings, suggestions, ...)
-      const isExternal = sourceFileMetadata?.isDefaultLibrary || sourceFileMetadata?.isFromExternalLibrary
-      if (isExternal && isNonCritical) return
-
-      // Get the source file and its metadata (if any) for the diagnostic...
-      // We do this *after* the external check above as getting the source file
-      // is quite expensive (especially for things like "lib.es5.dts")...
-      const sourceFile = diagnostic.fileName
-        ? ((await program.getSourceFile(diagnostic.fileName)) ??
-          (await program.getConfigSourceFile(diagnostic.fileName)))
-        : /* coverage ignore next */ undefined
-
-      // Convert our diagnostic to a report record and return it
-      return convertDiagnostic(diagnostic, sourceFile)
-    }),
-  )
+    // Convert our diagnostic to a report record and return it
+    return convertDiagnostic(diagnostic)
+  })
 
   // Filter out any null/undefined records
   return converted.filter((record): record is ReportRecord => !!record)
 }
-
-export async function convertProjectDiagnostics(
-  diagnostics: readonly Diagnostic[],
-  program: Program,
-  fileName: AbsolutePath,
-): Promise<ReportRecord[]> {
-  // Make sure that we have a file name for the diagnostics
-  const fileDiagnostics = diagnostics.map((diagnostic) => {
-    if (diagnostic.fileName) return diagnostic
-    return { ...diagnostic, fileName }
-  })
-
-  // Convert the diagnostics to report records and return them
-  return convertDiagnostics(fileDiagnostics, program)
-}

package/src/index.ts

@@ -1,12 +1,39 @@
 import { install } from '@plugjs/plug/pipe'
 
-import { TypeScript } from './typescript.ts'
+import { TypeScript, TypeScriptBuild } from './typescript.ts'
 
-/** Options for the {@link Pipe.typescript TypeScript} plug. */
-export interface TypeScriptOptions {
-  /** Whether referenced projects are built too. Defaults to `false`. */
-  projectReferences?: boolean
+import type { OverrideCompilerOptions } from 'typescript/unstable/async'
+
+/** Options for the `typescriptBuild` plug. */
+export interface TypeScriptBuildOptions {
+  /**
+   * Force building all projects in the build. Defaults to `true`.
+   *
+   * This is equivalent to running `tsc --build --force`.
+   */
+  force?: boolean
+
+  /**
+   * Skip building downstream projects on error in upstream project. Defaults
+   * to `false`.
+   *
+   * This is equivalent to running `tsc --build --stopBuildOnErrors`.
+   */
+  stopBuildOnErrors?: boolean
+
+  /**
+   * Enable verbose logging during the build. Defaults to `true`.
+   *
+   * This is equivalent to running `tsc --build --verbose`.
+   */
+  verbose?: boolean
+
+  /** Override the default TypeScript compiler options for the build. */
+  overrideCompilerOptions?: OverrideCompilerOptions
+}
 
+/** Options for the `typescript` plug. */
+export interface TypeScriptOptions {
   /**
    * Controls how deprecation diagnostics are reported. Use `'notice'` or
    * `true` for notices, `'warn'` for warnings, and `'off'` or `false` to
@@ -23,8 +50,14 @@ export interface TypeScriptOptions {
   emitOnly?: 'js' | 'dts' | 'all' | 'none' | boolean
 }
 
-/** Options for the {@link tsc} and {@link tsbuild} helpers. */
-export interface TscOptions extends Omit<TypeScriptOptions, 'projectReferences'> {
+/** Options for the {@link tsc} helper. */
+export interface TscOptions extends TypeScriptOptions {
+  /** Base directory used to resolve the configuration path. */
+  directory?: string
+}
+
+/** Options for the {@link tscBuild} helper. */
+export interface TscBuildOptions extends TypeScriptBuildOptions {
   /** Base directory used to resolve the configuration path. */
   directory?: string
 }
@@ -35,6 +68,8 @@ declare module '@plugjs/plug' {
      * Run the {@link https://www.typescriptlang.org/ TypeScript Compiler}
      * version 7 (native) over the `tsconfig.json` configuration files
      * given as input to this {@link Pipe} instance.
+     *
+     * This is equivalent to running `tsc --project`.
      */
     typescript(): Pipe
 
@@ -43,12 +78,35 @@ declare module '@plugjs/plug' {
      * version 7 (native) over the `tsconfig.json` configuration files
      * given as input to this {@link Pipe} instance.
      *
+     * This is equivalent to running `tsc --project`.
+     *
      * @param options {@link TypeScriptOptions} to use for the build.
      */
     typescript(options: TypeScriptOptions): Pipe
+
+    /**
+     * Run the {@link https://www.typescriptlang.org/ TypeScript Builder}
+     * version 7 (native) over the `tsconfig.json` configuration files
+     * given as input to this {@link Pipe} instance.
+     *
+     * This is equivalent to running `tsc --build`.
+     */
+    typescriptBuild(): Promise<undefined>
+
+    /**
+     * Run the {@link https://www.typescriptlang.org/ TypeScript Builder}
+     * version 7 (native) over the `tsconfig.json` configuration files
+     * given as input to this {@link Pipe} instance.
+     *
+     * This is equivalent to running `tsc --build`.
+     *
+     * @param options {@link TypeScriptBuildOptions} to use for the build.
+     */
+    typescriptBuild(options: TypeScriptBuildOptions): Promise<undefined>
   }
 }
 
 install('typescript', TypeScript)
+install('typescriptBuild', TypeScriptBuild)
 
 export { tsbuild, tsc } from './typescript.ts'

package/src/typescript.ts

@@ -1,166 +1,133 @@
 import { using } from '@plugjs/plug'
-import { assert } from '@plugjs/plug/asserts'
 import { Files } from '@plugjs/plug/files'
 import { ERROR } from '@plugjs/plug/logging'
-import { commonPath, getAbsoluteParent, resolveAbsolutePath } from '@plugjs/plug/paths'
-import { API, EmitOnly } from 'typescript/unstable/async'
+import { assertAbsolutePath, commonPath, isAbsolutePath } from '@plugjs/plug/paths'
+import { API, DiagnosticCategory } from 'typescript/unstable/async'
 
 import { convertDiagnostics } from './diagnostics.ts'
-import { findProjectConfig, findProjectReferences, readProjectConfig, resolveProjectOrder } from './projects.ts'
+import { diagnosticDeprecationLevel, emitOnlyOption, findProjectConfig } from './utils.ts'
 
-import type { TscOptions, TypeScriptOptions } from './index.ts'
+import type { TscBuildOptions, TscOptions, TypeScriptBuildOptions, TypeScriptOptions } from './index.ts'
 import type { Pipe } from '@plugjs/plug'
 import type { AbsolutePath } from '@plugjs/plug/paths'
 import type { Context, Plug } from '@plugjs/plug/pipe'
-import type { Snapshot } from 'typescript/unstable/async'
+import type { BuildOrchestrator } from 'typescript/unstable/async'
+import type { Diagnostic, RootedFilePath } from 'typescript/unstable/proto'
 
 /* ========================================================================== *
  * TYPESCRIPT 7 PLUG IMPLEMENTATION                                           *
  * ========================================================================== */
 
 export class TypeScript implements Plug<Files> {
-  private _emitOnly: EmitOnly | null
-  private _reportDeprecations: 'warn' | 'notice' | 'off'
-  private _projectReferences: boolean
-
-  constructor(options: TypeScriptOptions = {}) {
-    const { projectReferences, reportDeprecations, emitOnly } = options
-    this._projectReferences = !!projectReferences
-
-    switch (emitOnly) {
-      // If *none* or *false* we don't emit any files at all
-      case 'none':
-      case false:
-        this._emitOnly = null
-        break
-      // If *js* we only emit JavaScript files
-      case 'js':
-        this._emitOnly = EmitOnly.OnlyJs
-        break
-      // If *dts* we only emit declaration files
-      case 'dts':
-        this._emitOnly = EmitOnly.OnlyDts
-        break
-      // If *all* or *true* (default) we emit all files
-      case 'all':
-      case true:
-      default:
-        this._emitOnly = EmitOnly.All
-        break
-    }
-
-    switch (reportDeprecations) {
-      // If *warn* we report deprecations as warnings
-      case 'warn':
-        this._reportDeprecations = 'warn'
-        break
-      // If *off* or *false* we don't report deprecations at all
-      case 'off':
-      case false:
-        this._reportDeprecations = 'off'
-        break
-      // If *notice* or *true* (default) we report deprecations as notices
-      case 'notice':
-      case true:
-      default:
-        this._reportDeprecations = 'notice'
-        break
-    }
-  }
+  constructor(private readonly _options: TypeScriptOptions = {}) {}
 
   async pipe(files: Files, context: Context): Promise<Files> {
+    // Convert our options
+    const deprecationsLevel = diagnosticDeprecationLevel(this._options.reportDeprecations)
+    const emitOnly = emitOnlyOption(this._options.emitOnly)
+
     // Create our TypeScript API and report for this plug
-    const api = new API({ cwd: files.directory })
     const report = context.log.report('TypeScript Report')
 
     // This is the list of emitted files to return to the pipe...
     const emittedFiles: AbsolutePath[] = []
 
+    let api: API | undefined = undefined
     try {
-      // The list of projects to build (in order) and the snapshot used
-      // to build them.
-      let projects: AbsolutePath[]
-      let snapshot: Snapshot
-
-      // First of all figure out whether we have to build project references
-      // too or not... This will determine whether we have to resolve them....
-      if (this._projectReferences) {
-        // Find all project references for the given configuration files
-        const projectReferences = await findProjectReferences(api, ...files.absolutePaths())
-        report.add(...projectReferences.errors)
-        if (report.errors) report.done()
-
-        // Then determine the build order for all projects and their references
-        const projectOrder = resolveProjectOrder(projectReferences.projects)
-        report.add(...projectOrder.errors)
-        if (report.errors) report.done()
-
-        // At this point, our list of projects to build is the "order"
-        snapshot = await api.updateSnapshot({ openProjects: projectOrder.order })
-        projects = [...projectOrder.order]
-      } else {
-        // If we're not building references, then we just build our files
-        const configs = [...files.absolutePaths()].map(findProjectConfig)
-        snapshot = await api.updateSnapshot({ openProjects: configs })
-        projects = [...configs]
-
-        // When resolving the project references above, we already processed
-        // any configuration files and added any errors to the report...
-        // In this case, we have to do it ourselves by reading each config!
-        for (const config of configs) {
-          const { errors } = await readProjectConfig(api, config)
-          report.add(...errors)
-        }
+      api = new API({ cwd: files.directory })
 
-        // If we have any errors at this point, we can't continue...
-        if (report.errors) report.done()
-      }
+      // If we're not building references, then we just build our files
+      const configs = [...files.absolutePaths()].map(findProjectConfig)
+      const snapshot = await api.createSnapshot({ openProjects: configs })
+      const projects = snapshot.getProjects()
 
       // Now build all projects in the order we determined earlier
       for (const project of projects) {
         // Get the actual TypeScript program for this project...
-        const program = snapshot.getProject(project)?.program
-        assert(program, `Project "${project}" not found in snapshot`)
+        const program = project.program
 
         // Collect compilation diagnostics for this project (has files)
-        const diagnostics = await Promise.all([
+        const fullDiagnostics = await Promise.all([
           program.getBindDiagnostics(),
+          program.getConfigFileParsingDiagnostics(),
+          program.getDeclarationDiagnostics(),
+          program.getGlobalDiagnostics(),
+          program.getProgramDiagnostics(),
           program.getSemanticDiagnostics(),
-          program.getSyntacticDiagnostics(),
           program.getSuggestionDiagnostics(),
-          program.getDeclarationDiagnostics(),
+          program.getSyntacticDiagnostics(),
         ]).then((results) => results.flat())
 
+        // Keep a set of external files we can ignore non-critical diags for
+        const externalFiles = new Set<RootedFilePath>()
+
+        // Filter out diagnostics that are not relevant for this project
+        const now = Date.now()
+        const diagnostics = (
+          await Promise.all(
+            fullDiagnostics.map(async (diagnostic) => {
+              // Always keep all the errors...
+              if (diagnostic.category === DiagnosticCategory.Error) return diagnostic
+
+              // coverage ignore if // Keep diagnostics that do not have an associated file
+              if (!diagnostic.fileName) return diagnostic
+
+              // coverage ignore if // Before we do all the async resolution below, check our cache
+              if (externalFiles.has(diagnostic.fileName)) return undefined
+
+              // Get the source file metadata for this diagnostic (expensive)
+              // and filter out anything from external libraries....
+              const metadata = await program.getSourceFileMetadata(diagnostic.fileName)
+              if (metadata?.isDefaultLibrary || metadata?.isFromExternalLibrary) {
+                externalFiles.add(diagnostic.fileName)
+                return undefined
+              }
+
+              // Anything else, we keep!
+              return diagnostic
+            }),
+          )
+        ).filter((diagnostic): diagnostic is Diagnostic => !!diagnostic)
+        context.log.warn(`Filtered diagnostics in ${Date.now() - now}ms`)
+
         // When emitting, let's emit the files
-        if (this._emitOnly !== null) {
+        if (emitOnly !== null) {
           // Emit the files for this program and collect diagnostics
-          const emitted = await program.emit(this._emitOnly)
+          const emitted = await program.emit(emitOnly)
           diagnostics.push(...emitted.diagnostics)
 
           // Make sure that we add any emitted file to the list to be returned
           if (emitted.emittedFiles?.length) {
-            const directory = getAbsoluteParent(project)
-            const mapper = resolveAbsolutePath.bind(null, directory)
-            emittedFiles.push(...emitted.emittedFiles.map((file) => mapper(file)))
+            emitted.emittedFiles.forEach((file) => {
+              assertAbsolutePath(file)
+              emittedFiles.push(file)
+            })
           }
 
           // Report an error if emitting was skipped for some reason (we should
           // have some diagnostics associated with this, but still...)
           // coverage ignore if // don't know how to test this...
           if (emitted.emitSkipped) {
-            report.add({
-              level: ERROR,
-              message: `Unable to emit files for this project`,
-              file: project,
-            })
+            if (project.configFileName && isAbsolutePath(project.configFileName)) {
+              report.add({
+                level: ERROR,
+                message: `Unable to emit files for this project`,
+                file: project.configFileName,
+              })
+            } else {
+              report.add({
+                level: ERROR,
+                message: `Unable to emit files for unknown project`,
+              })
+            }
           }
         }
 
         // Add all diagnostics to the report
-        report.add(...(await convertDiagnostics(diagnostics, program, this._reportDeprecations)))
+        report.add(...convertDiagnostics(diagnostics, deprecationsLevel))
       }
     } finally {
-      await api.close()
+      if (api) await api.close()
     }
 
     report.done()
@@ -172,6 +139,48 @@ export class TypeScript implements Plug<Files> {
   }
 }
 
+export class TypeScriptBuild implements Plug<void> {
+  constructor(private readonly _options: TypeScriptBuildOptions = {}) {}
+
+  async pipe(files: Files, context: Context): Promise<void> {
+    // Destructure the build options for easier access
+    const { overrideCompilerOptions = {}, stopBuildOnErrors = false, verbose = true, force = true } = this._options
+
+    // Create our TypeScript API and report for this plug
+    const report = context.log.report('TypeScript Build Report')
+
+    let api: API | undefined = undefined
+    let orchestrator: BuildOrchestrator | undefined = undefined
+    try {
+      api = new API({ cwd: files.directory })
+      orchestrator = await api.createBuildOrchestrator([...files.absolutePaths()], {
+        cwd: files.directory,
+        // From our options
+        overrideCompilerOptions,
+        stopBuildOnErrors,
+        verbose,
+        force,
+      })
+
+      const results = await orchestrator.build()
+
+      if (results.diagnostics) report.add(...convertDiagnostics(results.diagnostics))
+
+      if (results.status !== 0) {
+        report.add({
+          level: ERROR,
+          message: `Build failed with status code ${results.status}`,
+        })
+      }
+    } finally {
+      if (orchestrator) await orchestrator.dispose()
+      if (api) await api.close()
+    }
+
+    report.done()
+  }
+}
+
 /* ========================================================================== *
  * TYPESCRIPT 7 HELPERS                                                       *
  * ========================================================================== */
@@ -184,7 +193,7 @@ export class TypeScript implements Plug<Files> {
  */
 export function tsc(config: string, options: TscOptions = {}): Pipe {
   const { directory, ...opts } = options
-  return using(config, { directory }).plug(new TypeScript({ ...opts, projectReferences: false }))
+  return using(config, { directory }).plug(new TypeScript(opts))
 }
 
 /* ========================================================================== */
@@ -196,7 +205,7 @@ export function tsc(config: string, options: TscOptions = {}): Pipe {
  *
  * This is roughly equivalent to the command line `tsc --build <config>`.
  */
-export function tsbuild(config: string, options: TscOptions = {}): Pipe {
+export function tsbuild(config: string, options: TscBuildOptions): Promise<undefined> {
   const { directory, ...opts } = options
-  return using(config, { directory }).plug(new TypeScript({ ...opts, projectReferences: true }))
+  return using(config, { directory }).plug(new TypeScriptBuild(opts))
 }