@tsonic/backend 0.0.1

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@tsonic/backend",
+  "version": "0.0.1",
+  "description": ".NET build orchestration for Tsonic compiler",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "test": "mocha 'dist/**/*.test.js'",
+    "test:watch": "mocha 'dist/**/*.test.js' --watch"
+  },
+  "dependencies": {
+    "@tsonic/emitter": "0.0.1",
+    "@tsonic/frontend": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/chai": "5.2.2",
+    "@types/mocha": "10.0.10",
+    "@types/node": "20.14.0",
+    "chai": "5.3.3",
+    "mocha": "11.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/build-orchestrator.ts

@@ -0,0 +1,215 @@
+/**
+ * Main build orchestration - coordinates the entire NativeAOT build process
+ */
+
+import { createHash } from "crypto";
+import {
+  mkdirSync,
+  writeFileSync,
+  copyFileSync,
+  rmSync,
+  chmodSync,
+  existsSync,
+  readdirSync,
+} from "fs";
+import { join, dirname } from "path";
+import {
+  BuildOptions,
+  BuildResult,
+  BuildConfig,
+  EntryInfo,
+  NuGetPackage,
+} from "./types.js";
+import { generateCsproj } from "./project-generator.js";
+import { generateProgramCs } from "./program-generator.js";
+import { checkDotnetInstalled, detectRid, publishNativeAot } from "./dotnet.js";
+
+/**
+ * Create unique build directory
+ */
+const createBuildDir = (entryFile: string): string => {
+  const hash = createHash("md5").update(entryFile).digest("hex").slice(0, 8);
+  const buildDir = join(process.cwd(), ".tsonic", "build", hash);
+  mkdirSync(buildDir, { recursive: true });
+  return buildDir;
+};
+
+/**
+ * Copy generated C# files to build directory
+ */
+const copyGeneratedFiles = (
+  emittedFiles: Map<string, string>,
+  buildDir: string
+): void => {
+  for (const [tsPath, csContent] of emittedFiles) {
+    // src/models/User.ts → <buildDir>/src/models/User.cs
+    const csPath = tsPath.replace(/\.ts$/, ".cs");
+    const fullPath = join(buildDir, csPath);
+
+    mkdirSync(dirname(fullPath), { recursive: true });
+    writeFileSync(fullPath, csContent, "utf-8");
+  }
+};
+
+/**
+ * Find project .csproj file in current directory
+ */
+const findProjectCsproj = (): string | null => {
+  const cwd = process.cwd();
+  // Look for *.csproj in current directory
+  const files = readdirSync(cwd);
+  const csprojFile = files.find((f) => f.endsWith(".csproj"));
+  return csprojFile ? join(cwd, csprojFile) : null;
+};
+
+/**
+ * Get output binary name for platform
+ */
+const getOutputBinaryName = (outputName: string): string => {
+  return process.platform === "win32" ? `${outputName}.exe` : outputName;
+};
+
+/**
+ * Copy output binary to final location
+ */
+const copyOutputBinary = (
+  buildDir: string,
+  rid: string,
+  outputPath: string,
+  outputName: string
+): void => {
+  const publishDir = join(buildDir, "bin/Release/net8.0", rid, "publish");
+  const binaryName = getOutputBinaryName(outputName);
+  const binaryPath = join(publishDir, binaryName);
+
+  if (!existsSync(binaryPath)) {
+    throw new Error(`Output binary not found at ${binaryPath}`);
+  }
+
+  copyFileSync(binaryPath, outputPath);
+
+  // Make executable on Unix
+  if (process.platform !== "win32") {
+    chmodSync(outputPath, 0o755);
+  }
+};
+
+/**
+ * Clean build directory
+ */
+const cleanBuild = (buildDir: string, keepTemp: boolean): void => {
+  if (!keepTemp) {
+    rmSync(buildDir, { recursive: true, force: true });
+  }
+};
+
+/**
+ * Build NativeAOT executable from C# files
+ */
+export const buildNativeAot = (
+  emittedFiles: Map<string, string>,
+  entryInfo: EntryInfo,
+  options: BuildOptions
+): BuildResult => {
+  let buildDir: string | undefined;
+
+  try {
+    // Check dotnet is installed
+    const dotnetCheck = checkDotnetInstalled();
+    if (!dotnetCheck.ok) {
+      return {
+        ok: false,
+        error: dotnetCheck.error,
+      };
+    }
+
+    // Create build directory
+    buildDir = createBuildDir(Array.from(emittedFiles.keys())[0] || "main");
+
+    // Copy generated C# files
+    copyGeneratedFiles(emittedFiles, buildDir);
+
+    // Generate Program.cs if needed
+    if (entryInfo.needsProgram) {
+      const programCs = generateProgramCs(entryInfo);
+      writeFileSync(join(buildDir, "Program.cs"), programCs, "utf-8");
+    }
+
+    // Use existing project .csproj if available, otherwise generate one
+    const projectCsproj = findProjectCsproj();
+    if (projectCsproj) {
+      // Copy existing .csproj to build directory (preserves user edits)
+      const csprojFilename = projectCsproj.split("/").pop() || "project.csproj";
+      copyFileSync(projectCsproj, join(buildDir, csprojFilename));
+    } else {
+      // Generate temporary .csproj for build
+      // Tsonic.Runtime is ALWAYS required (for unions, typeof, structural)
+      // Tsonic.JSRuntime only when mode: "js" (for JS semantics)
+      const packages: NuGetPackage[] = [
+        { name: "Tsonic.Runtime", version: "0.0.1" },
+      ];
+      if (entryInfo.runtime === "js") {
+        packages.push({ name: "Tsonic.JSRuntime", version: "0.0.1" });
+      }
+
+      const buildConfig: BuildConfig = {
+        rootNamespace: options.namespace,
+        outputName: options.outputName || "tsonic",
+        dotnetVersion: options.dotnetVersion || "net10.0",
+        packages,
+        outputConfig: {
+          type: "executable",
+          nativeAot: true,
+          singleFile: true,
+          trimmed: true,
+          stripSymbols: options.stripSymbols ?? true,
+          optimization: options.optimizationPreference || "Speed",
+          invariantGlobalization: true,
+          selfContained: true,
+        },
+      };
+
+      const csprojContent = generateCsproj(buildConfig);
+      writeFileSync(join(buildDir, "tsonic.csproj"), csprojContent, "utf-8");
+    }
+
+    // Detect RID
+    const rid = options.rid || detectRid();
+
+    // Execute dotnet publish
+    const publishResult = publishNativeAot(buildDir, rid);
+    if (!publishResult.ok) {
+      return {
+        ok: false,
+        error: publishResult.error,
+        buildDir,
+      };
+    }
+
+    // Copy output binary
+    const outputPath = options.outputName
+      ? `./${getOutputBinaryName(options.outputName)}`
+      : "./tsonic-app";
+    copyOutputBinary(buildDir, rid, outputPath, options.outputName || "tsonic");
+
+    // Cleanup if requested
+    cleanBuild(buildDir, options.keepTemp ?? false);
+
+    return {
+      ok: true,
+      outputPath,
+      buildDir,
+    };
+  } catch (error) {
+    if (buildDir) {
+      cleanBuild(buildDir, false);
+    }
+
+    return {
+      ok: false,
+      error:
+        error instanceof Error ? error.message : "Unknown build error occurred",
+      buildDir,
+    };
+  }
+};

package/src/dotnet.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Tests for dotnet CLI wrapper
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { detectRid } from "./dotnet.js";
+
+describe("Dotnet CLI Wrapper", () => {
+  describe("detectRid", () => {
+    it("should return a valid runtime identifier", () => {
+      const rid = detectRid();
+
+      // Should match one of the known RID patterns
+      const validRids = [
+        "osx-x64",
+        "osx-arm64",
+        "linux-x64",
+        "linux-arm64",
+        "win-x64",
+        "win-arm64",
+      ];
+
+      expect(validRids).to.include(rid);
+    });
+
+    it("should detect current platform RID", () => {
+      const rid = detectRid();
+      const platform = process.platform;
+      const arch = process.arch;
+
+      if (platform === "darwin") {
+        expect(rid).to.match(/^osx-/);
+      } else if (platform === "linux") {
+        expect(rid).to.match(/^linux-/);
+      } else if (platform === "win32") {
+        expect(rid).to.match(/^win-/);
+      }
+
+      if (arch === "x64") {
+        expect(rid).to.include("x64");
+      } else if (arch === "arm64") {
+        expect(rid).to.include("arm64");
+      }
+    });
+  });
+
+  // Note: checkDotnetInstalled and publishNativeAot are integration tests
+  // that require dotnet to be installed, so we skip them in unit tests
+});

package/src/dotnet.ts

@@ -0,0 +1,101 @@
+/**
+ * Dotnet CLI wrapper for executing build commands
+ */
+
+import { spawnSync } from "child_process";
+import { DotnetResult } from "./types.js";
+
+/**
+ * Check if dotnet CLI is available
+ */
+export const checkDotnetInstalled = (): DotnetResult => {
+  const result = spawnSync("dotnet", ["--version"], {
+    encoding: "utf-8",
+  });
+
+  if (result.error) {
+    return {
+      ok: false,
+      error: ".NET SDK not found. Install from https://dot.net",
+    };
+  }
+
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      error: "dotnet command failed",
+      stderr: result.stderr,
+    };
+  }
+
+  return {
+    ok: true,
+    stdout: result.stdout.trim(),
+  };
+};
+
+/**
+ * Detect runtime identifier for current platform
+ */
+export const detectRid = (): string => {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const ridMap: Record<string, string> = {
+    "darwin-x64": "osx-x64",
+    "darwin-arm64": "osx-arm64",
+    "linux-x64": "linux-x64",
+    "linux-arm64": "linux-arm64",
+    "win32-x64": "win-x64",
+    "win32-arm64": "win-arm64",
+  };
+
+  const key = `${platform}-${arch}`;
+  return ridMap[key] || "linux-x64";
+};
+
+/**
+ * Execute dotnet publish with NativeAOT
+ */
+export const publishNativeAot = (
+  buildDir: string,
+  rid: string
+): DotnetResult => {
+  const args = [
+    "publish",
+    "tsonic.csproj",
+    "-c",
+    "Release",
+    "-r",
+    rid,
+    "-p:PublishAot=true",
+    "-p:PublishSingleFile=true",
+    "--self-contained",
+  ];
+
+  const result = spawnSync("dotnet", args, {
+    cwd: buildDir,
+    encoding: "utf-8",
+  });
+
+  if (result.error) {
+    return {
+      ok: false,
+      error: `Failed to execute dotnet: ${result.error.message}`,
+    };
+  }
+
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      error: `dotnet publish failed with code ${result.status}`,
+      stdout: result.stdout,
+      stderr: result.stderr,
+    };
+  }
+
+  return {
+    ok: true,
+    stdout: result.stdout,
+  };
+};

package/src/index.ts

@@ -0,0 +1,28 @@
+/**
+ * Tsonic Backend - .NET build orchestration
+ */
+
+// Export main build function
+export { buildNativeAot } from "./build-orchestrator.js";
+
+// Export types
+export type {
+  BuildOptions,
+  BuildResult,
+  BuildConfig,
+  EntryInfo,
+  NuGetPackage,
+  DotnetResult,
+  OutputType,
+  OutputConfig,
+  ExecutableConfig,
+  LibraryConfig,
+  ConsoleAppConfig,
+  PackageMetadata,
+  AssemblyReference,
+} from "./types.js";
+
+// Export utilities
+export { checkDotnetInstalled, detectRid } from "./dotnet.js";
+export { generateCsproj } from "./project-generator.js";
+export { generateProgramCs } from "./program-generator.js";

package/src/program-generator.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Tests for Program.cs generation
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { generateProgramCs } from "./program-generator.js";
+import { EntryInfo } from "./types.js";
+
+describe("Program Generator", () => {
+  describe("generateProgramCs", () => {
+    it("should generate synchronous Main method", () => {
+      const entryInfo: EntryInfo = {
+        namespace: "MyApp",
+        className: "main",
+        methodName: "start",
+        isAsync: false,
+        needsProgram: true,
+      };
+
+      const result = generateProgramCs(entryInfo);
+
+      expect(result).to.include("public static void Main(string[] args)");
+      expect(result).to.include("main.start();");
+      expect(result).to.not.include("await");
+      expect(result).to.not.include("async");
+      expect(result).to.include("using MyApp;");
+    });
+
+    it("should generate async Main method", () => {
+      const entryInfo: EntryInfo = {
+        namespace: "MyApp.Services",
+        className: "main",
+        methodName: "run",
+        isAsync: true,
+        needsProgram: true,
+      };
+
+      const result = generateProgramCs(entryInfo);
+
+      expect(result).to.include("public static async Task Main(string[] args)");
+      expect(result).to.include("await main.run();");
+      expect(result).to.include("using MyApp.Services;");
+      expect(result).to.include("using System.Threading.Tasks;");
+    });
+
+    it("should include required using statements", () => {
+      const entryInfo: EntryInfo = {
+        namespace: "Test",
+        className: "Program",
+        methodName: "Main",
+        isAsync: false,
+        needsProgram: true,
+      };
+
+      const result = generateProgramCs(entryInfo);
+
+      expect(result).to.include("using System;");
+      expect(result).to.include("using Tsonic.Runtime;");
+      expect(result).to.include("using Test;");
+    });
+  });
+});

package/src/program-generator.ts

@@ -0,0 +1,33 @@
+/**
+ * Program.cs generation for entry point wrapper
+ */
+
+import { EntryInfo } from "./types.js";
+
+/**
+ * Generate Program.cs content with Main method
+ */
+export const generateProgramCs = (entryInfo: EntryInfo): string => {
+  const returnType = entryInfo.isAsync ? "async Task" : "void";
+  const awaitKeyword = entryInfo.isAsync ? "await " : "";
+
+  const usings = ["using System;", "using System.Threading.Tasks;"];
+
+  // Only include Tsonic.Runtime for js runtime mode
+  if (entryInfo.runtime !== "dotnet") {
+    usings.push("using Tsonic.Runtime;");
+  }
+
+  usings.push(`using ${entryInfo.namespace};`);
+
+  return `${usings.join("\n")}
+
+public static class Program
+{
+    public static ${returnType} Main(string[] args)
+    {
+        ${awaitKeyword}${entryInfo.className}.${entryInfo.methodName}();
+    }
+}
+`;
+};

package/src/project-generator.test.ts

@@ -0,0 +1,130 @@
+/**
+ * Tests for .csproj generation
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { generateCsproj } from "./project-generator.js";
+import { BuildConfig } from "./types.js";
+
+describe("Project Generator", () => {
+  describe("generateCsproj", () => {
+    it("should generate basic executable .csproj without packages", () => {
+      const config: BuildConfig = {
+        rootNamespace: "TestApp",
+        outputName: "test",
+        dotnetVersion: "net10.0",
+        packages: [],
+        outputConfig: {
+          type: "executable",
+          nativeAot: true,
+          singleFile: true,
+          trimmed: true,
+          stripSymbols: true,
+          optimization: "Speed",
+          invariantGlobalization: true,
+          selfContained: true,
+        },
+      };
+
+      const result = generateCsproj(config);
+
+      expect(result).to.include('<Project Sdk="Microsoft.NET.Sdk">');
+      expect(result).to.include("<TargetFramework>net10.0</TargetFramework>");
+      expect(result).to.include("<RootNamespace>TestApp</RootNamespace>");
+      expect(result).to.include("<AssemblyName>test</AssemblyName>");
+      expect(result).to.include("<PublishAot>true</PublishAot>");
+      expect(result).to.include(
+        "<OptimizationPreference>Speed</OptimizationPreference>"
+      );
+    });
+
+    it("should include package references when provided", () => {
+      const config: BuildConfig = {
+        rootNamespace: "TestApp",
+        outputName: "test",
+        dotnetVersion: "net10.0",
+        packages: [
+          { name: "System.Text.Json", version: "8.0.0" },
+          { name: "Newtonsoft.Json", version: "13.0.3" },
+        ],
+        outputConfig: {
+          type: "executable",
+          nativeAot: true,
+          singleFile: true,
+          trimmed: true,
+          stripSymbols: true,
+          optimization: "Size",
+          invariantGlobalization: true,
+          selfContained: true,
+        },
+      };
+
+      const result = generateCsproj(config);
+
+      expect(result).to.include(
+        '<PackageReference Include="System.Text.Json" Version="8.0.0"'
+      );
+      expect(result).to.include(
+        '<PackageReference Include="Newtonsoft.Json" Version="13.0.3"'
+      );
+      expect(result).to.include(
+        "<OptimizationPreference>Size</OptimizationPreference>"
+      );
+    });
+
+    it("should set invariant globalization correctly", () => {
+      const config: BuildConfig = {
+        rootNamespace: "TestApp",
+        outputName: "test",
+        dotnetVersion: "net10.0",
+        packages: [],
+        outputConfig: {
+          type: "executable",
+          nativeAot: true,
+          singleFile: true,
+          trimmed: true,
+          stripSymbols: false,
+          optimization: "Speed",
+          invariantGlobalization: false,
+          selfContained: true,
+        },
+      };
+
+      const result = generateCsproj(config);
+
+      expect(result).to.include(
+        "<InvariantGlobalization>false</InvariantGlobalization>"
+      );
+      expect(result).to.include("<StripSymbols>false</StripSymbols>");
+    });
+
+    it("should generate library .csproj", () => {
+      const config: BuildConfig = {
+        rootNamespace: "TestLib",
+        outputName: "testlib",
+        dotnetVersion: "net10.0",
+        packages: [],
+        outputConfig: {
+          type: "library",
+          targetFrameworks: ["net8.0", "net9.0"],
+          generateDocumentation: true,
+          includeSymbols: true,
+          packable: false,
+        },
+      };
+
+      const result = generateCsproj(config);
+
+      expect(result).to.include("<OutputType>Library</OutputType>");
+      expect(result).to.include(
+        "<TargetFrameworks>net8.0;net9.0</TargetFrameworks>"
+      );
+      expect(result).to.include(
+        "<GenerateDocumentationFile>true</GenerateDocumentationFile>"
+      );
+      expect(result).to.include("<DebugType>embedded</DebugType>");
+      expect(result).to.include("<IsPackable>false</IsPackable>");
+    });
+  });
+});

package/src/project-generator.ts

@@ -0,0 +1,245 @@
+/**
+ * .csproj file generation for multiple output types
+ */
+
+import {
+  BuildConfig,
+  NuGetPackage,
+  OutputConfig,
+  ExecutableConfig,
+  LibraryConfig,
+  ConsoleAppConfig,
+  PackageMetadata,
+  AssemblyReference,
+} from "./types.js";
+
+/**
+ * Generate package references XML
+ */
+const formatPackageReferences = (packages: readonly NuGetPackage[]): string => {
+  if (packages.length === 0) {
+    return "";
+  }
+
+  const refs = packages
+    .map(
+      (pkg) =>
+        `    <PackageReference Include="${pkg.name}" Version="${pkg.version}" />`
+    )
+    .join("\n");
+
+  return `
+  <ItemGroup>
+${refs}
+  </ItemGroup>`;
+};
+
+/**
+ * Generate assembly references XML (for DLL files)
+ */
+const formatAssemblyReferences = (
+  refs: readonly AssemblyReference[]
+): string => {
+  if (refs.length === 0) {
+    return "";
+  }
+
+  const refElements = refs
+    .map(
+      (ref) =>
+        `    <Reference Include="${ref.name}">
+      <HintPath>${ref.hintPath}</HintPath>
+    </Reference>`
+    )
+    .join("\n");
+
+  return `
+  <ItemGroup>
+${refElements}
+  </ItemGroup>`;
+};
+
+/**
+ * Capitalize first letter
+ */
+const capitalizeFirst = (str: string): string => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+
+/**
+ * Generate NuGet package metadata properties
+ */
+const generatePackageMetadata = (metadata: PackageMetadata): string => {
+  const authors = metadata.authors.join(";");
+  const tags = metadata.tags?.join(";") || "";
+
+  return `
+    <PackageId>${metadata.id}</PackageId>
+    <Version>${metadata.version}</Version>
+    <Authors>${authors}</Authors>
+    <Description>${metadata.description}</Description>${metadata.projectUrl ? `\n    <PackageProjectUrl>${metadata.projectUrl}</PackageProjectUrl>` : ""}${metadata.license ? `\n    <PackageLicenseExpression>${metadata.license}</PackageLicenseExpression>` : ""}${tags ? `\n    <PackageTags>${tags}</PackageTags>` : ""}`;
+};
+
+/**
+ * Generate property group for executable output
+ */
+const generateExecutableProperties = (
+  config: BuildConfig,
+  execConfig: ExecutableConfig
+): string => {
+  const nativeAotSettings = execConfig.nativeAot
+    ? `
+    <!-- NativeAOT settings -->
+    <PublishAot>true</PublishAot>
+    <PublishSingleFile>${execConfig.singleFile}</PublishSingleFile>
+    <PublishTrimmed>${execConfig.trimmed}</PublishTrimmed>
+    <InvariantGlobalization>${execConfig.invariantGlobalization}</InvariantGlobalization>
+    <StripSymbols>${execConfig.stripSymbols}</StripSymbols>
+
+    <!-- Optimization -->
+    <OptimizationPreference>${capitalizeFirst(execConfig.optimization)}</OptimizationPreference>
+    <IlcOptimizationPreference>${capitalizeFirst(execConfig.optimization)}</IlcOptimizationPreference>`
+    : `
+    <PublishSingleFile>${execConfig.singleFile}</PublishSingleFile>
+    <SelfContained>${execConfig.selfContained}</SelfContained>`;
+
+  return `  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>${config.dotnetVersion}</TargetFramework>
+    <RootNamespace>${config.rootNamespace}</RootNamespace>
+    <AssemblyName>${config.outputName}</AssemblyName>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>false</ImplicitUsings>${nativeAotSettings}
+  </PropertyGroup>`;
+};
+
+/**
+ * Generate property group for library output
+ */
+const generateLibraryProperties = (
+  config: BuildConfig,
+  libConfig: LibraryConfig
+): string => {
+  const targetFrameworks = libConfig.targetFrameworks.join(";");
+  const isMultiTarget = libConfig.targetFrameworks.length > 1;
+  const targetProp = isMultiTarget
+    ? `<TargetFrameworks>${targetFrameworks}</TargetFrameworks>`
+    : `<TargetFramework>${libConfig.targetFrameworks[0]}</TargetFramework>`;
+
+  const docSettings = libConfig.generateDocumentation
+    ? `
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>`
+    : "";
+
+  const symbolSettings = libConfig.includeSymbols
+    ? `
+    <DebugType>embedded</DebugType>
+    <DebugSymbols>true</DebugSymbols>`
+    : `
+    <DebugType>none</DebugType>`;
+
+  const packageSettings =
+    libConfig.packable && libConfig.packageMetadata
+      ? generatePackageMetadata(libConfig.packageMetadata)
+      : "";
+
+  return `  <PropertyGroup>
+    <OutputType>Library</OutputType>
+    ${targetProp}
+    <RootNamespace>${config.rootNamespace}</RootNamespace>
+    <AssemblyName>${config.outputName}</AssemblyName>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>false</ImplicitUsings>${docSettings}${symbolSettings}
+    <IsPackable>${libConfig.packable}</IsPackable>${packageSettings}
+  </PropertyGroup>`;
+};
+
+/**
+ * Generate property group for console app output
+ */
+const generateConsoleAppProperties = (
+  config: BuildConfig,
+  consoleConfig: ConsoleAppConfig
+): string => {
+  return `  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>${consoleConfig.targetFramework}</TargetFramework>
+    <RootNamespace>${config.rootNamespace}</RootNamespace>
+    <AssemblyName>${config.outputName}</AssemblyName>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>false</ImplicitUsings>
+    <PublishSingleFile>${consoleConfig.singleFile}</PublishSingleFile>
+    <SelfContained>${consoleConfig.selfContained}</SelfContained>
+  </PropertyGroup>`;
+};
+
+/**
+ * Generate property group based on output type
+ */
+const generatePropertyGroup = (
+  config: BuildConfig,
+  outputConfig: OutputConfig
+): string => {
+  switch (outputConfig.type) {
+    case "executable":
+      return generateExecutableProperties(config, outputConfig);
+    case "library":
+      return generateLibraryProperties(config, outputConfig);
+    case "console-app":
+      return generateConsoleAppProperties(config, outputConfig);
+  }
+};
+
+/**
+ * Generate complete .csproj file content
+ */
+export const generateCsproj = (config: BuildConfig): string => {
+  const packageRefs = formatPackageReferences(config.packages);
+  const assemblyRefs = formatAssemblyReferences(
+    config.assemblyReferences ?? []
+  );
+  const runtimeRef = config.runtimePath
+    ? `
+  <ItemGroup>
+    <ProjectReference Include="${config.runtimePath}" />
+  </ItemGroup>`
+    : "";
+
+  const propertyGroup = generatePropertyGroup(config, config.outputConfig);
+
+  return `<Project Sdk="Microsoft.NET.Sdk">
+${propertyGroup}${packageRefs}${assemblyRefs}${runtimeRef}
+</Project>
+`;
+};
+
+/**
+ * Legacy function for backward compatibility
+ * @deprecated Use generateCsproj with outputConfig instead
+ */
+export const generateCsprojLegacy = (
+  config: BuildConfig & {
+    invariantGlobalization?: boolean;
+    stripSymbols?: boolean;
+    optimizationPreference?: "Size" | "Speed";
+  }
+): string => {
+  // Convert legacy config to new format
+  const execConfig: ExecutableConfig = {
+    type: "executable",
+    nativeAot: true,
+    singleFile: true,
+    trimmed: true,
+    stripSymbols: config.stripSymbols ?? true,
+    optimization: config.optimizationPreference ?? "Speed",
+    invariantGlobalization: config.invariantGlobalization ?? true,
+    selfContained: true,
+  };
+
+  const newConfig: BuildConfig = {
+    ...config,
+    outputConfig: execConfig,
+  };
+
+  return generateCsproj(newConfig);
+};

package/src/types.ts

@@ -0,0 +1,150 @@
+/**
+ * Type definitions for backend build process
+ */
+
+/**
+ * NuGet package reference
+ */
+export type NuGetPackage = {
+  readonly name: string;
+  readonly version: string;
+};
+
+/**
+ * Output type taxonomy
+ */
+export type OutputType = "executable" | "library" | "console-app";
+
+/**
+ * NuGet package metadata for libraries
+ */
+export type PackageMetadata = {
+  readonly id: string;
+  readonly version: string;
+  readonly authors: readonly string[];
+  readonly description: string;
+  readonly projectUrl?: string;
+  readonly license?: string;
+  readonly tags?: readonly string[];
+};
+
+/**
+ * Executable-specific configuration
+ */
+export type ExecutableConfig = {
+  readonly type: "executable";
+  readonly nativeAot: boolean;
+  readonly singleFile: boolean;
+  readonly trimmed: boolean;
+  readonly stripSymbols: boolean;
+  readonly optimization: "Size" | "Speed";
+  readonly invariantGlobalization: boolean;
+  readonly selfContained: boolean;
+};
+
+/**
+ * Library-specific configuration
+ */
+export type LibraryConfig = {
+  readonly type: "library";
+  readonly targetFrameworks: readonly string[];
+  readonly generateDocumentation: boolean;
+  readonly includeSymbols: boolean;
+  readonly packable: boolean;
+  readonly packageMetadata?: PackageMetadata;
+};
+
+/**
+ * Console app configuration (non-NativeAOT)
+ */
+export type ConsoleAppConfig = {
+  readonly type: "console-app";
+  readonly selfContained: boolean;
+  readonly singleFile: boolean;
+  readonly targetFramework: string;
+};
+
+/**
+ * Output configuration union type
+ */
+export type OutputConfig = ExecutableConfig | LibraryConfig | ConsoleAppConfig;
+
+/**
+ * Assembly reference (for DLL files)
+ */
+export type AssemblyReference = {
+  readonly name: string;
+  readonly hintPath: string;
+};
+
+/**
+ * Build configuration options
+ */
+export type BuildConfig = {
+  readonly rootNamespace: string;
+  readonly outputName: string;
+  readonly dotnetVersion: string;
+  readonly runtimePath?: string;
+  readonly assemblyReferences?: readonly AssemblyReference[];
+  readonly packages: readonly NuGetPackage[];
+  readonly outputConfig: OutputConfig;
+  // Legacy fields for backward compatibility
+  readonly invariantGlobalization?: boolean;
+  readonly stripSymbols?: boolean;
+  readonly optimizationPreference?: "Size" | "Speed";
+};
+
+/**
+ * Entry point information
+ */
+export type EntryInfo = {
+  readonly namespace: string;
+  readonly className: string;
+  readonly methodName: string;
+  readonly isAsync: boolean;
+  readonly needsProgram: boolean;
+  readonly runtime?: "js" | "dotnet";
+};
+
+/**
+ * Build options passed to buildNativeAot
+ */
+export type BuildOptions = {
+  readonly namespace: string;
+  readonly outputName?: string;
+  readonly dotnetVersion?: string;
+  readonly rid?: string;
+  readonly keepTemp?: boolean;
+  readonly stripSymbols?: boolean;
+  readonly optimizationPreference?: "Size" | "Speed";
+};
+
+/**
+ * Result of the build process
+ */
+export type BuildResult =
+  | {
+      readonly ok: true;
+      readonly outputPath: string;
+      readonly buildDir: string;
+    }
+  | {
+      readonly ok: false;
+      readonly error: string;
+      readonly buildDir?: string;
+    };
+
+/**
+ * Dotnet execution result
+ */
+export type DotnetResult =
+  | {
+      readonly ok: true;
+      readonly stdout: string;
+    }
+  | {
+      readonly ok: false;
+      readonly error: string;
+      readonly stdout?: string;
+      readonly stderr?: string;
+    };

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "tsBuildInfoFile": "./dist/.tsbuildinfo"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../frontend" }, { "path": "../emitter" }]
+}