@git.zone/tsrust 1.13.0 → 1.14.0

package/ts/mod_cli/classes.tsrustcli.ts

@@ -1,3 +1,4 @@
+import { withTargetCacheLock } from '../mod_cargo/classes.targetguard.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -23,9 +24,15 @@ import {
 } from '../mod_provenance/index.js';
 import { ToolchainManager } from '../mod_toolchain/index.js';
 import { NativeMatrixBuilder } from '../mod_matrix/index.js';
+import {
+  assertNoStaticGlibc,
+  createProjectNoticesGenerator,
+  staticGlibcArtifactError,
+} from '../mod_notices/index.js';
 import { commitinfo } from '../00_commitinfo_data.js';
 import {
   configuredAssemblyTargets,
+  friendlyTargetName,
   normalizeTargets,
   resolveBuildTargets,
   type ITsrustConfig,
@@ -61,6 +68,7 @@ export class TsRustCli {
 
   private registerCommands(): void {
     this.registerStandardCommand();
+    this.registerNoticesCommand();
     this.registerCleanCommand();
     this.registerPruneCommand();
     this.registerAssembleCommand();
@@ -121,7 +129,7 @@ export class TsRustCli {
    * then falls back to a bundled toolchain at /tmp/tsrust_toolchain/.
    * Returns the envPrefix string to prepend to shell commands.
    */
-  private async resolveToolchain(): Promise<string> {
+  private async resolveToolchain(installArg: boolean = true): Promise<string> {
     // 1. Try system cargo
     const systemRunner = new CargoRunner(this.cwd);
     if (await systemRunner.checkCargoInstalled()) {
@@ -131,6 +139,12 @@ export class TsRustCli {
     // 2. Fall back to bundled toolchain
     console.log('System cargo not found. Checking for bundled toolchain...');
     const toolchain = new ToolchainManager();
+    if (!installArg) {
+      if (!(await toolchain.isInstalled())) {
+        throw new Error('No Rust toolchain is installed; install rustup or run `tsrust notices` (checks install nothing)');
+      }
+      return toolchain.getEnvPrefix();
+    }
     await toolchain.ensureInstalled();
     return toolchain.getEnvPrefix();
   }
@@ -175,7 +189,6 @@ export class TsRustCli {
       const distDir = path.join(this.cwd, 'dist_rust');
       const profile = isDebug ? 'debug' : 'release';
       const managedTargetDir = resolveManagedTargetDir(this.cwd, this.config.targetDir);
-      await writeTargetCacheMarker(managedTargetDir);
 
       // CLI targets override host-specific and legacy configured targets.
       const cliTargets = (argvArg as any).target;
@@ -184,47 +197,172 @@ export class TsRustCli {
         : undefined;
       const hostTriple = new ToolchainManager().getHostTriple();
       const resolvedTargets = resolveBuildTargets(this.config, hostTriple, cliTargetList);
-
       const useStatic = !!(argvArg as any).static || !!this.config.static;
-      if (useStatic) {
-        console.log('Static linking enabled (crt-static for linux-gnu targets)');
-      }
 
-      const rustflags = this.buildRustflags(rustDir);
-      if (rustflags.length > 0) {
-        console.log(`Using additional Rust flags: ${rustflags.join(' ')}`);
+      // With native notices, static glibc is refused by every build. Matrix
+      // workers pass --no-notices-check, which skips only the bundle comparison:
+      // their coordinator verified the notices of the exact commit.
+      if (this.config.notices !== undefined) {
+        assertNoStaticGlibc({
+          targets: resolvedTargets.length > 0
+            ? resolvedTargets
+            : [{ triple: hostTriple, friendly: friendlyTargetName(hostTriple) }],
+          staticLinking: useStatic,
+          rustflags: this.config.rustflags || [],
+          environment: process.env,
+        });
+      }
+      if (this.config.notices !== undefined && (argvArg as any).noticesCheck !== false) {
+        const noticeTriples = new Set(configuredAssemblyTargets(this.config).map((target) => target.triple));
+        const uncovered = resolvedTargets.filter((target) => !noticeTriples.has(target.triple));
+        if (resolvedTargets.length === 0 || uncovered.length > 0) {
+          throw new Error(
+            `Native notices cover the configured targets only; cannot build ${
+              uncovered.map((target) => target.friendly).join(', ') || 'the native host target'
+            }`,
+          );
+        }
+        const bundle = await (await createProjectNoticesGenerator({
+          projectDir: this.cwd,
+          rustDir,
+          config: this.config,
+          staticLinking: useStatic,
+          envPrefix,
+          install: false,
+        })).check();
+        console.log(`Verified native notices: ${path.relative(this.cwd, bundle.directory)}`);
       }
 
-      if (resolvedTargets.length > 0) {
-        // Cross-compilation mode
-        console.log(
-          `Cross-compiling for: ${resolvedTargets.map((target) => `${target.friendly} (${target.triple})`).join(', ')}`,
-        );
+      await withTargetCacheLock(managedTargetDir, async () => {
+        await writeTargetCacheMarker(managedTargetDir);
 
-        await FsHelpers.ensureEmptyDir(distDir);
+        if (useStatic) {
+          console.log('Static linking enabled (crt-static for linux-gnu targets)');
+        }
 
-        for (const { triple, friendly } of resolvedTargets) {
-          console.log(`\n--- Building for ${friendly} (${triple}) ---`);
-          if (useStatic && !isLinuxTriple(triple)) {
-            console.log(
-              `Note: static linking is not applicable for ${triple}; building with default linkage.`,
-            );
+        const rustflags = this.buildRustflags(rustDir);
+        if (rustflags.length > 0) {
+          console.log(`Using additional Rust flags: ${rustflags.join(' ')}`);
+        }
+
+        if (resolvedTargets.length > 0) {
+          // Cross-compilation mode
+          console.log(
+            `Cross-compiling for: ${resolvedTargets.map((target) => `${target.friendly} (${target.triple})`).join(', ')}`,
+          );
+
+          await FsHelpers.ensureEmptyDir(distDir);
+
+          for (const { triple, friendly } of resolvedTargets) {
+            console.log(`\n--- Building for ${friendly} (${triple}) ---`);
+            if (useStatic && !isLinuxTriple(triple)) {
+              console.log(
+                `Note: static linking is not applicable for ${triple}; building with default linkage.`,
+              );
+            }
+            const cargoRunner = new CargoRunner(rustDir, envPrefix);
+            const gitBefore = await captureGitSnapshot(this.cwd);
+            const provenanceBefore = this.collectBuildProvenance(gitBefore);
+            const buildResult = await cargoRunner.build({
+              debug: isDebug,
+              clean: shouldClean,
+              target: triple,
+              locked: this.config.locked === true,
+              crtStatic: useStatic && wantsCrtStatic(triple),
+              rustflags,
+              targetDir: managedTargetDir,
+            });
+
+            if (!buildResult.success) {
+              console.error(`Build failed for target ${triple} with exit code ${buildResult.exitCode}`);
+              process.exit(1);
+            }
+            const gitAfter = await captureGitSnapshot(this.cwd);
+            assertGitSnapshotUnchanged(gitBefore, gitAfter);
+            const provenanceAfter = this.collectBuildProvenance(gitAfter);
+            this.assertProjectIdentityUnchanged(provenanceBefore, provenanceAfter);
+
+            const targetDir = getCargoArtifactDir(managedTargetDir, profile, triple);
+
+            for (const binName of workspaceInfo.binTargets) {
+              const srcBinary = path.join(targetDir, binName);
+              const destName = `${binName}_${friendly}`;
+              const destBinary = path.join(distDir, destName);
+
+              if (!(await FsHelpers.fileExists(srcBinary))) {
+                console.warn(`Warning: Expected binary not found: ${srcBinary}`);
+                continue;
+              }
+
+              if (isDarwinTriple(triple)) {
+                const signatureResult = await ensureDarwinCodeSignature(srcBinary);
+                console.log(
+                  `${signatureResult === 'applied' ? 'Applied' : 'Verified'} Darwin code signature: ${srcBinary}`,
+                );
+              }
+              await FsHelpers.copyFile(srcBinary, destBinary);
+              await FsHelpers.makeExecutable(destBinary);
+
+              const size = await FsHelpers.getFileSize(destBinary);
+              console.log(
+                `Copied ${binName} (${FsHelpers.formatFileSize(size)}) -> dist_rust/${destName}`,
+              );
+              await this.assertNoticesLinkage(destBinary, triple, friendly);
+
+              if (useStatic && isLinuxTriple(triple)) {
+                if (!(await ElfInspector.isStaticElf(destBinary))) {
+                  console.error(
+                    `Error: ${destName} is not statically linked (PT_INTERP present) although static linking was requested.`,
+                  );
+                  process.exit(1);
+                }
+                console.log(`Verified statically linked: dist_rust/${destName}`);
+              }
+
+              await ProvenanceStore.write(destBinary, {
+                ...provenanceBefore,
+                binary: binName,
+                target: friendly,
+              });
+              console.log(
+                `Wrote provenance: ${provenanceBefore.projectName}@${provenanceBefore.projectVersion} ${provenanceBefore.gitCommit.slice(0, 12)} (${friendly})`,
+              );
+            }
+
+            // Only clean on first iteration
+            if (shouldClean) {
+              shouldClean = false;
+            }
           }
+        } else {
+          // Native build. When static linking is requested, build with an
+          // explicit host --target so RUSTFLAGS never reach host artifacts
+          // (proc-macros cannot build with +crt-static on linux-gnu).
+          let nativeTriple: string | undefined;
+          if (useStatic) {
+            nativeTriple = hostTriple;
+            if (!isLinuxTriple(nativeTriple)) {
+              console.log(
+                `Note: static linking is not applicable for ${nativeTriple}; building with default linkage.`,
+              );
+            }
+          }
+
           const cargoRunner = new CargoRunner(rustDir, envPrefix);
           const gitBefore = await captureGitSnapshot(this.cwd);
           const provenanceBefore = this.collectBuildProvenance(gitBefore);
           const buildResult = await cargoRunner.build({
             debug: isDebug,
             clean: shouldClean,
-            target: triple,
+            target: nativeTriple,
             locked: this.config.locked === true,
-            crtStatic: useStatic && wantsCrtStatic(triple),
+            crtStatic: !!nativeTriple && wantsCrtStatic(nativeTriple),
             rustflags,
             targetDir: managedTargetDir,
           });
 
           if (!buildResult.success) {
-            console.error(`Build failed for target ${triple} with exit code ${buildResult.exitCode}`);
+            console.error(`Build failed with exit code ${buildResult.exitCode}`);
             process.exit(1);
           }
           const gitAfter = await captureGitSnapshot(this.cwd);
@@ -232,19 +370,20 @@ export class TsRustCli {
           const provenanceAfter = this.collectBuildProvenance(gitAfter);
           this.assertProjectIdentityUnchanged(provenanceBefore, provenanceAfter);
 
-          const targetDir = getCargoArtifactDir(managedTargetDir, profile, triple);
+          const targetDir = getCargoArtifactDir(managedTargetDir, profile, nativeTriple);
+
+          await FsHelpers.ensureEmptyDir(distDir);
 
           for (const binName of workspaceInfo.binTargets) {
             const srcBinary = path.join(targetDir, binName);
-            const destName = `${binName}_${friendly}`;
-            const destBinary = path.join(distDir, destName);
+            const destBinary = path.join(distDir, binName);
 
             if (!(await FsHelpers.fileExists(srcBinary))) {
               console.warn(`Warning: Expected binary not found: ${srcBinary}`);
               continue;
             }
 
-            if (isDarwinTriple(triple)) {
+            if (isDarwinTriple(hostTriple)) {
               const signatureResult = await ensureDarwinCodeSignature(srcBinary);
               console.log(
                 `${signatureResult === 'applied' ? 'Applied' : 'Verified'} Darwin code signature: ${srcBinary}`,
@@ -255,130 +394,89 @@ export class TsRustCli {
 
             const size = await FsHelpers.getFileSize(destBinary);
             console.log(
-              `Copied ${binName} (${FsHelpers.formatFileSize(size)}) -> dist_rust/${destName}`,
+              `Copied ${binName} (${FsHelpers.formatFileSize(size)}) -> dist_rust/${binName}`,
             );
+            const builtTriple = nativeTriple || hostTriple;
+            await this.assertNoticesLinkage(destBinary, builtTriple, friendlyTargetName(builtTriple));
 
-            if (useStatic && isLinuxTriple(triple)) {
+            if (useStatic && nativeTriple && isLinuxTriple(nativeTriple)) {
               if (!(await ElfInspector.isStaticElf(destBinary))) {
                 console.error(
-                  `Error: ${destName} is not statically linked (PT_INTERP present) although static linking was requested.`,
+                  `Error: ${binName} is not statically linked (PT_INTERP present) although static linking was requested.`,
                 );
                 process.exit(1);
               }
-              console.log(`Verified statically linked: dist_rust/${destName}`);
+              console.log(`Verified statically linked: dist_rust/${binName}`);
             }
 
             await ProvenanceStore.write(destBinary, {
               ...provenanceBefore,
               binary: binName,
-              target: friendly,
+              target: nativeTriple || 'native',
             });
             console.log(
-              `Wrote provenance: ${provenanceBefore.projectName}@${provenanceBefore.projectVersion} ${provenanceBefore.gitCommit.slice(0, 12)} (${friendly})`,
-            );
-          }
-
-          // Only clean on first iteration
-          if (shouldClean) {
-            shouldClean = false;
-          }
-        }
-      } else {
-        // Native build. When static linking is requested, build with an
-        // explicit host --target so RUSTFLAGS never reach host artifacts
-        // (proc-macros cannot build with +crt-static on linux-gnu).
-        let nativeTriple: string | undefined;
-        if (useStatic) {
-          nativeTriple = hostTriple;
-          if (!isLinuxTriple(nativeTriple)) {
-            console.log(
-              `Note: static linking is not applicable for ${nativeTriple}; building with default linkage.`,
+              `Wrote provenance: ${provenanceBefore.projectName}@${provenanceBefore.projectVersion} ${provenanceBefore.gitCommit.slice(0, 12)} (${nativeTriple || 'native'})`,
             );
           }
         }
 
-        const cargoRunner = new CargoRunner(rustDir, envPrefix);
-        const gitBefore = await captureGitSnapshot(this.cwd);
-        const provenanceBefore = this.collectBuildProvenance(gitBefore);
-        const buildResult = await cargoRunner.build({
-          debug: isDebug,
-          clean: shouldClean,
-          target: nativeTriple,
-          locked: this.config.locked === true,
-          crtStatic: !!nativeTriple && wantsCrtStatic(nativeTriple),
-          rustflags,
-          targetDir: managedTargetDir,
-        });
-
-        if (!buildResult.success) {
-          console.error(`Build failed with exit code ${buildResult.exitCode}`);
-          process.exit(1);
+        if (this.shouldPruneAfterBuild()) {
+          const plan = await createTsrustPrunePlan({
+            workspace: this.cwd,
+            targetDir: managedTargetDir,
+            days: 0,
+          });
+          await applyTsrustPrunePlan(plan);
+          console.log('Pruned marked tsrust target cache after successful build.');
         }
-        const gitAfter = await captureGitSnapshot(this.cwd);
-        assertGitSnapshotUnchanged(gitBefore, gitAfter);
-        const provenanceAfter = this.collectBuildProvenance(gitAfter);
-        this.assertProjectIdentityUnchanged(provenanceBefore, provenanceAfter);
-
-        const targetDir = getCargoArtifactDir(managedTargetDir, profile, nativeTriple);
-
-        await FsHelpers.ensureEmptyDir(distDir);
-
-        for (const binName of workspaceInfo.binTargets) {
-          const srcBinary = path.join(targetDir, binName);
-          const destBinary = path.join(distDir, binName);
 
-          if (!(await FsHelpers.fileExists(srcBinary))) {
-            console.warn(`Warning: Expected binary not found: ${srcBinary}`);
-            continue;
-          }
-
-          if (isDarwinTriple(hostTriple)) {
-            const signatureResult = await ensureDarwinCodeSignature(srcBinary);
-            console.log(
-              `${signatureResult === 'applied' ? 'Applied' : 'Verified'} Darwin code signature: ${srcBinary}`,
-            );
-          }
-          await FsHelpers.copyFile(srcBinary, destBinary);
-          await FsHelpers.makeExecutable(destBinary);
+      });
 
-          const size = await FsHelpers.getFileSize(destBinary);
-          console.log(
-            `Copied ${binName} (${FsHelpers.formatFileSize(size)}) -> dist_rust/${binName}`,
-          );
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+      console.log(`\nDone in ${elapsed}s`);
+    });
+  }
 
-          if (useStatic && nativeTriple && isLinuxTriple(nativeTriple)) {
-            if (!(await ElfInspector.isStaticElf(destBinary))) {
-              console.error(
-                `Error: ${binName} is not statically linked (PT_INTERP present) although static linking was requested.`,
-              );
-              process.exit(1);
-            }
-            console.log(`Verified statically linked: dist_rust/${binName}`);
-          }
+  /**
+   * With native notices, a Linux GNU binary must load glibc dynamically: a
+   * binary without an ELF interpreter is removed and the build fails.
+   */
+  private async assertNoticesLinkage(binaryArg: string, tripleArg: string, friendlyArg: string): Promise<void> {
+    if (this.config.notices === undefined || !tripleArg.endsWith('-linux-gnu')) return;
+    if (await ElfInspector.isStaticElf(binaryArg)) {
+      await fs.promises.rm(binaryArg, { force: true });
+      throw staticGlibcArtifactError(friendlyArg, tripleArg);
+    }
+  }
 
-          await ProvenanceStore.write(destBinary, {
-            ...provenanceBefore,
-            binary: binName,
-            target: nativeTriple || 'native',
-          });
-          console.log(
-            `Wrote provenance: ${provenanceBefore.projectName}@${provenanceBefore.projectVersion} ${provenanceBefore.gitCommit.slice(0, 12)} (${nativeTriple || 'native'})`,
-          );
-        }
+  /**
+   * `tsrust notices` writes the third-party notices of the configured native
+   * targets; `tsrust notices --check` verifies them without writing.
+   */
+  private registerNoticesCommand(): void {
+    this.cli.addCommand('notices').subscribe(async (argvArg) => {
+      if (this.config.notices === undefined) {
+        throw new Error('Native notices are not configured: add "notices" to the @git.zone/tsrust configuration');
       }
-
-      if (this.shouldPruneAfterBuild()) {
-        const plan = await createTsrustPrunePlan({
-          workspace: this.cwd,
-          targetDir: managedTargetDir,
-          days: 0,
-        });
-        await applyTsrustPrunePlan(plan);
-        console.log('Pruned marked tsrust target cache after successful build.');
+      const rustDir = await this.detectRustDir();
+      if (!rustDir) {
+        throw new Error('No rust/ or ts_rust/ directory found with a Cargo.toml');
       }
-
-      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-      console.log(`\nDone in ${elapsed}s`);
+      const check = !!(argvArg as any).check;
+      const envPrefix = await this.resolveToolchain(!check);
+      const staticLinking = !!(argvArg as any).static || !!this.config.static;
+      const generator = await createProjectNoticesGenerator({
+        projectDir: this.cwd,
+        rustDir,
+        config: this.config,
+        staticLinking,
+        envPrefix,
+        install: !check,
+      });
+      const bundle = check ? await generator.check() : await generator.write();
+      console.log(
+        `${check ? 'Verified' : 'Wrote'} ${bundle.files.size} native notice files in ${path.relative(this.cwd, bundle.directory)}`,
+      );
     });
   }
 
@@ -551,11 +649,12 @@ export class TsRustCli {
       const daysArg = (argvArg as any).days;
       const days = daysArg === undefined ? 14 : Number(daysArg);
       const maxSizeBytes = parseSizeToBytes((argvArg as any).maxSize as string | undefined);
+      if ((argvArg as any).maxSize !== undefined && maxSizeBytes === undefined) throw new Error('Invalid --max-size');
       const apply = !!(argvArg as any).apply;
       const plan = await createTsrustPrunePlan({
         workspace,
         targetDir: resolveManagedTargetDir(workspace, this.config.targetDir),
-        days: Number.isFinite(days) ? days : 14,
+        days,
         maxSizeBytes,
       });
 

package/ts/mod_cli/helpers.targets.ts

@@ -1,4 +1,5 @@
 import type { ITsrustMatrixConfig } from '../mod_matrix/helpers.matrixconfig.js';
+import type { ITsrustNoticesConfig } from '../mod_notices/helpers.noticesconfig.js';
 
 export const targetAliasMap: Record<string, string> = {
   linux_amd64: 'x86_64-unknown-linux-gnu',
@@ -32,6 +33,7 @@ export interface ITsrustConfig {
   targetDir?: string;
   pruneAfterBuild?: boolean;
   matrix?: ITsrustMatrixConfig;
+  notices?: ITsrustNoticesConfig;
 }
 
 export interface INormalizedTarget {

package/ts/mod_matrix/classes.nativematrixbuilder.ts

@@ -17,6 +17,7 @@ import {
 } from '../mod_provenance/index.js';
 import { ToolchainManager } from '../mod_toolchain/index.js';
 import { friendlyTargetName, type ITsrustConfig } from '../mod_cli/helpers.targets.js';
+import { createProjectNoticesGenerator } from '../mod_notices/index.js';
 import { commitinfo } from '../00_commitinfo_data.js';
 import {
   MatrixCommandRunner,
@@ -157,6 +158,8 @@ export interface INativeMatrixBuilderOptions {
   config: ITsrustConfig;
   environment?: NodeJS.ProcessEnv;
   commandRunner?: IMatrixCommandRunner;
+  /** Verifies the native notices on the coordinator; defaults to `tsrust notices --check`. */
+  verifyNotices?: () => Promise<void>;
 }
 
 export interface INativeMatrixCheckResult {
@@ -221,9 +224,13 @@ export class NativeMatrixBuilder {
   private readonly environment: NodeJS.ProcessEnv;
   private readonly commandRunner: IMatrixCommandRunner;
   private readonly plan: IResolvedMatrixPlan;
+  private readonly config: ITsrustConfig;
+  private readonly verifyNoticesOverride?: () => Promise<void>;
 
   constructor(optionsArg: INativeMatrixBuilderOptions) {
     this.workspace = path.resolve(optionsArg.workspace);
+    this.config = optionsArg.config;
+    this.verifyNoticesOverride = optionsArg.verifyNotices;
     this.environment = { ...process.env, ...(optionsArg.environment || {}) };
     this.commandRunner =
       optionsArg.commandRunner || new MatrixCommandRunner(this.environment);
@@ -233,6 +240,7 @@ export class NativeMatrixBuilder {
 
   public async check(): Promise<INativeMatrixCheckResult> {
     await this.assertBundleCompatibleSource();
+    await this.verifyNotices();
     await this.commandRunner.execute('git', ['--version'], {
       cwd: this.workspace,
       capture: true,
@@ -1008,9 +1016,45 @@ export class NativeMatrixBuilder {
       'exec',
       'tsrust',
       ...workerArg.targets.flatMap((target) => ['--target', target.friendly]),
+      // The coordinator verified the notices of this commit in check().
+      ...(this.config.notices === undefined ? [] : ['--no-notices-check']),
     ];
   }
 
+  /** Native notices are verified once, here on the coordinator, for all targets. */
+  private async verifyNotices(): Promise<void> {
+    if (this.config.notices === undefined) return;
+    if (this.verifyNoticesOverride) {
+      await this.verifyNoticesOverride();
+      return;
+    }
+    let envPrefix = '';
+    try {
+      await this.commandRunner.execute('cargo', ['--version'], {
+        cwd: this.workspace,
+        capture: true,
+        timeoutMs: capabilityCommandTimeoutMs,
+      });
+    } catch {
+      // The check installs nothing: use the bundled toolchain only if present.
+      const toolchainManager = new ToolchainManager();
+      if (!(await toolchainManager.isInstalled())) {
+        throw new Error('Native notices check needs a Rust toolchain on the coordinator; install rustup or run `tsrust notices`');
+      }
+      envPrefix = toolchainManager.getEnvPrefix();
+    }
+    const generator = await createProjectNoticesGenerator({
+      projectDir: this.workspace,
+      rustDir: await this.detectRustDirectory(),
+      config: this.config,
+      staticLinking: this.config.static === true,
+      envPrefix,
+      install: false,
+    });
+    const bundle = await generator.check();
+    console.log(`Verified native notices: ${path.relative(this.workspace, bundle.directory)}`);
+  }
+
   private workerVerificationArgs(workerArg: IResolvedMatrixWorker): string[] {
     const bootstrap = "import { ToolchainManager } from './node_modules/@git.zone/tsrust/dist_ts/mod_toolchain/index.js'; await new ToolchainManager().ensureInstalled();";
     return [