semantifold 0.8.0 → 0.10.0

package/index.js

@@ -16,6 +16,15 @@ export {SemantifoldDiagnostic}
 export {createCapabilityAuthority} from "./src/semantic/capabilities.js"
 export {languageCapabilities, supportedLanguages} from "./src/language-registry.js"
 export {createGeneratedArtifactSet} from "./src/artifacts.js"
+export {GeneratedArtifactPublisher} from "./src/publication.js"
+export {ProjectManifestLoader, SemantifoldProject} from "./src/project-manifest.js"
+export {ProjectSnapshot, ProjectSnapshotBuilder} from "./src/project-snapshot.js"
+export {ProjectBuilder} from "./src/project-build.js"
+export {parseSemantifoldCliArguments, SemantifoldCli} from "./src/project-cli.js"
+export {ProjectBuildReporter} from "./src/project-reporter.js"
+export {ProjectWatchCoordinator} from "./src/project-watch.js"
+export {ProjectWatchReporter} from "./src/project-watch-reporter.js"
+export {createTargetCheckPlan, TargetCheckRunner} from "./src/target-check.js"
 export {createStdlibContractRegistry, listStdlibModules, resolveStdlibModule} from "./src/semantic/stdlib.js"
 export {createStdlibProviderRegistry, listStdlibProviders} from "./src/stdlib-providers.js"
 export {negotiateStdlibProviders} from "./src/stdlib-negotiation.js"

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "semantifold",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Language-neutral semantic code analysis, transformation, generation, and execution toolkit",
   "type": "module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
+  "bin": {
+    "semantifold": "bin/semantifold.js"
+  },
   "exports": {
     ".": {
       "types": "./build/index.d.ts",
@@ -13,7 +16,9 @@
   },
   "files": [
     "build/**",
+    "bin/**",
     "docs/**",
+    "examples/**",
     "index.js",
     "LICENSE",
     "README.md",

package/src/artifact-path.js

@@ -52,18 +52,47 @@ export function portableArtifactPathKey(value) {
   return value.toLowerCase()
 }
 
+/**
+ * Produces a deterministic case-fold comparison key for a validated source path.
+ * @param {string} value - Safe relative POSIX source path.
+ * @returns {string} Unicode case-fold comparison key.
+ */
+export function portableSourcePathKey(value) {
+  return value.toLowerCase()
+}
+
 /**
  * Finds the first unsafe, duplicate, portable case-fold, or file/directory-prefix conflict.
  * @param {readonly string[]} paths - Ordered candidate artifact paths.
  * @returns {{kind: "case-fold" | "duplicate" | "prefix" | "unsafe", path: string, other?: string} | null} First conflict.
  */
 export function findPortableArtifactPathConflict(paths) {
+  return findPortablePathConflict(paths, isSafeArtifactPath, portableArtifactPathKey)
+}
+
+/**
+ * Finds the first unsafe, duplicate, portable case-fold, or file/directory-prefix source conflict.
+ * @param {readonly string[]} paths - Ordered candidate source paths.
+ * @returns {{kind: "case-fold" | "duplicate" | "prefix" | "unsafe", path: string, other?: string} | null} First conflict.
+ */
+export function findPortableSourcePathConflict(paths) {
+  return findPortablePathConflict(paths, isSafeSourcePath, portableSourcePathKey)
+}
+
+/**
+ * Compares paths inside one explicitly selected validation domain.
+ * @param {readonly string[]} paths - Ordered candidate paths.
+ * @param {(value: unknown) => boolean} isSafe - Domain-specific path validator.
+ * @param {(value: string) => string} comparisonKey - Domain-specific portable comparison key.
+ * @returns {{kind: "case-fold" | "duplicate" | "prefix" | "unsafe", path: string, other?: string} | null} First conflict.
+ */
+function findPortablePathConflict(paths, isSafe, comparisonKey) {
   /** @type {{key: string, path: string}[]} */
   const accepted = []
 
   for (const path of paths) {
-    if (!isSafeArtifactPath(path)) return {kind: "unsafe", path: String(path)}
-    const key = portableArtifactPathKey(path)
+    if (!isSafe(path)) return {kind: "unsafe", path: String(path)}
+    const key = comparisonKey(path)
 
     for (const previous of accepted) {
       if (path == previous.path) return {kind: "duplicate", other: previous.path, path}

package/src/backends/c-check.js

@@ -0,0 +1,80 @@
+// @ts-check
+
+import path from "node:path"
+import {SemantifoldDiagnostic} from "../diagnostic.js"
+import {
+  checkArtifacts,
+  checkOutput,
+  checkPlan,
+  checkStage,
+  checkTool,
+  environmentPath,
+  pathArgument
+} from "./check-plan.js"
+import {cRuntimeHeader} from "./c-runtime.js"
+
+const compilerFlags = Object.freeze([
+  "--no-default-config", "-std=c17", "-Wall", "-Wextra", "-Werror", "-pedantic-errors", "-Wconversion",
+  "-Wsign-conversion", "-Wshadow", "-Wstrict-prototypes", "-Wmissing-prototypes", "-Wformat=2", "-ftrapv",
+  "-finput-charset=UTF-8", "-fexec-charset=UTF-8", "-fno-color-diagnostics", "-O0"
+])
+
+/**
+ * Constructs C's strict Clang C17 compile/link plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable C plan.
+ */
+export function createCCheckPlan(context) {
+  const tool = checkTool(context, "clang", "c")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".c") || artifact.path.endsWith(".h"),
+    "c", "only staged C translation units and headers")
+  const sources = artifacts.filter(artifact => artifact.endsWith(".c"))
+  const headers = artifacts.filter(artifact => artifact.endsWith(".h"))
+  const support = context.artifacts.artifacts.filter(artifact => artifact.path == "semantifold_runtime.h")
+
+  if (artifacts.length != 2 || sources.length != 1 || sources[0] != path.join(context.sourcePath, "program.c") ||
+    headers.length != 1 || support.length != 1 || support[0].contentKind != "text" || support[0].role != "support" ||
+    support[0].content != cRuntimeHeader) {
+    throw new SemantifoldDiagnostic({code: "INVALID_TARGET_CHECK_PLAN", language: "c",
+      message: "C developer checks require the exact producer-owned translation unit and support header."})
+  }
+  const objects = path.join(context.buildPath, "objects")
+  const temporary = path.join(context.buildPath, "tmp")
+  const environment = {TMPDIR: temporary}
+  const environmentPaths = [environmentPath("TMPDIR", "build")]
+  const objectPaths = sources.map((_, index) => path.join(objects, `${String(index).padStart(6, "0")}.o`))
+  const stages = sources.map((source, index) => {
+    const argv = [...compilerFlags, "-c", source, "-o", objectPaths[index]]
+
+    return checkStage({
+      argv,
+      cwd: context.sourcePath,
+      environment,
+      environmentPaths,
+      inputs: [source, ...headers],
+      output: null,
+      pathArguments: [pathArgument(argv.length - 3, "source"), pathArgument(argv.length - 1, "build")],
+      stage: /** @type {const} */ ("compile"),
+      tool,
+      transientPaths: [objects]
+    })
+  })
+  const binary = path.join(context.buildPath, "semantifold-c")
+  const linkArgv = ["--no-default-config", "-O0", ...objectPaths, "-o", binary]
+
+  stages.push(checkStage({
+    argv: linkArgv,
+    cwd: context.sourcePath,
+    environment,
+    environmentPaths,
+    inputs: objectPaths,
+    output: checkOutput(context.buildPath, "application/x-executable", "linker-output"),
+    pathArguments: [...objectPaths.map((_, index) => pathArgument(index + 2, "build")),
+      pathArgument(linkArgv.length - 1, "build")],
+    stage: "link",
+    tool,
+    transientPaths: [objects]
+  }))
+
+  return checkPlan(context, "c", artifacts, stages)
+}

package/src/backends/check-plan.js

@@ -0,0 +1,147 @@
+// @ts-check
+
+import path from "node:path"
+import {SemantifoldDiagnostic} from "../diagnostic.js"
+import {deterministicEnvironment} from "../toolchains.js"
+
+/**
+ * Resolves one target-declared discovered tool from immutable plan context.
+ * @param {Readonly<{tools: readonly import("../semantic/types.js").DiscoveredToolchain[]}>} context - Plan context.
+ * @param {string} id - Declared toolchain identity.
+ * @param {string} target - Target diagnostic identity.
+ * @returns {import("../semantic/types.js").DiscoveredToolchain} Exact tool.
+ */
+export function checkTool(context, id, target) {
+  const tool = context.tools.find(candidate => candidate.id == id)
+
+  if (!tool) {
+    throw new SemantifoldDiagnostic({
+      code: "INVALID_TARGET_CHECK_PLAN",
+      language: target,
+      message: `Target '${target}' developer checks require the declared '${id}' toolchain.`
+    })
+  }
+
+  return tool
+}
+
+/**
+ * Resolves all staged artifacts matching one target-owned predicate.
+ * @param {Readonly<{artifacts: import("../semantic/types.js").GeneratedArtifactSet, sourcePath: string}>} context - Plan context.
+ * @param {(artifact: import("../semantic/types.js").GeneratedSetArtifact) => boolean} accepts - Target-owned artifact predicate.
+ * @param {string} target - Target diagnostic identity.
+ * @param {string} description - Required artifact description.
+ * @returns {readonly string[]} Ordered absolute artifact paths.
+ */
+export function checkArtifacts(context, accepts, target, description) {
+  const accepted = context.artifacts.artifacts.filter(accepts)
+
+  if (accepted.length == 0 || accepted.length != context.artifacts.artifacts.length) {
+    throw new SemantifoldDiagnostic({
+      code: "INVALID_TARGET_CHECK_PLAN",
+      language: target,
+      message: `Target '${target}' developer checks require ${description}.`
+    })
+  }
+
+  return Object.freeze(accepted.map(artifact => path.join(context.sourcePath, artifact.path))
+    .sort((left, right) => left.localeCompare(right, "en")))
+}
+
+/**
+ * Freezes one closed target-check stage request.
+ * @param {object} input - Complete stage data.
+ * @param {readonly string[]} input.argv - Exact argv.
+ * @param {string} input.cwd - Candidate-owned working directory.
+ * @param {Readonly<Record<string, string | undefined>>} [input.environment] - Target-owned environment additions.
+ * @param {readonly import("../semantic/types.js").TargetCheckEnvironmentPath[]} [input.environmentPaths] - Owned environment paths.
+ * @param {string | null} [input.inputHash] - Restore-input hash when applicable.
+ * @param {readonly string[]} input.inputs - Exact staged inputs read by the tool.
+ * @param {import("../semantic/types.js").TargetCheckOutputOwnership | null} input.output - Produced build ownership.
+ * @param {readonly import("../semantic/types.js").TargetCheckPathArgument[]} input.pathArguments - Owned argv paths.
+ * @param {import("../semantic/types.js").AcceptanceStage} input.stage - Stage identity.
+ * @param {import("../semantic/types.js").DiscoveredToolchain} input.tool - Exact tool.
+ * @param {readonly string[]} [input.transientPaths] - Owned cache/intermediate directories.
+ * @returns {import("../semantic/types.js").TargetCheckStageRequest} Immutable stage.
+ */
+export function checkStage(input) {
+  return Object.freeze({
+    argv: Object.freeze([...input.argv]),
+    cwd: input.cwd,
+    environment: deterministicEnvironment(input.environment ?? {}),
+    environmentPaths: Object.freeze([...(input.environmentPaths ?? [])]),
+    executable: input.tool.executable,
+    inputHash: input.inputHash ?? null,
+    inputs: Object.freeze([...input.inputs]),
+    output: input.output,
+    pathArguments: Object.freeze([...input.pathArguments]),
+    stage: input.stage,
+    tool: input.tool,
+    transientPaths: Object.freeze([...(input.transientPaths ?? [])])
+  })
+}
+
+/**
+ * Freezes one closed target-owned plan.
+ * @param {Readonly<{buildPath: string, projectId: string, sourcePath: string, targetId: string}>} context - Plan context.
+ * @param {string} target - Target identity.
+ * @param {readonly string[]} artifactPaths - Complete staged artifact vector.
+ * @param {readonly import("../semantic/types.js").TargetCheckStageRequest[]} stages - Ordered stages.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable plan.
+ */
+export function checkPlan(context, target, artifactPaths, stages) {
+  return Object.freeze({
+    artifactPaths,
+    buildPath: context.buildPath,
+    mode: /** @type {const} */ ("developer-check"),
+    projectId: context.projectId,
+    schema: /** @type {const} */ ("SemantifoldTargetCheckPlan"),
+    sourcePath: context.sourcePath,
+    stages: Object.freeze([...stages]),
+    target,
+    targetId: context.targetId,
+    version: /** @type {const} */ (1)
+  })
+}
+
+/**
+ * Freezes one owned argv-path declaration.
+ * @param {number} index - Exact argv index.
+ * @param {"source" | "build"} ownership - Owning candidate subtree.
+ * @param {string} [prefix] - Optional non-path argument prefix.
+ * @returns {import("../semantic/types.js").TargetCheckPathArgument} Immutable declaration.
+ */
+export function pathArgument(index, ownership, prefix) {
+  return Object.freeze({index, ownership, ...(prefix === undefined ? {} : {prefix})})
+}
+
+/**
+ * Freezes one owned environment-directory declaration.
+ * @param {string} name - Exact environment variable.
+ * @param {"source" | "build"} ownership - Owning candidate subtree.
+ * @returns {import("../semantic/types.js").TargetCheckEnvironmentPath} Immutable declaration.
+ */
+export function environmentPath(name, ownership) {
+  return Object.freeze({name, ownership})
+}
+
+/**
+ * Freezes one exact tool-executable environment binding.
+ * @param {string} name - Exact environment variable.
+ * @param {import("../semantic/types.js").DiscoveredToolchain} tool - Exact discovered tool.
+ * @returns {import("../semantic/types.js").TargetCheckEnvironmentPath} Immutable declaration.
+ */
+export function environmentTool(name, tool) {
+  return Object.freeze({name, ownership: /** @type {const} */ ("tool"), tool})
+}
+
+/**
+ * Freezes build-output ownership metadata.
+ * @param {string} buildPath - Exact candidate build root.
+ * @param {string} mediaType - Output media type.
+ * @param {string} role - Language-neutral output role.
+ * @returns {import("../semantic/types.js").TargetCheckOutputOwnership} Immutable ownership.
+ */
+export function checkOutput(buildPath, mediaType, role) {
+  return Object.freeze({mediaType, ownership: /** @type {const} */ ("build"), path: buildPath, role})
+}

package/src/backends/cpp-check.js

@@ -0,0 +1,73 @@
+// @ts-check
+
+import path from "node:path"
+import {SemantifoldDiagnostic} from "../diagnostic.js"
+import {
+  checkArtifacts,
+  checkOutput,
+  checkPlan,
+  checkStage,
+  checkTool,
+  environmentPath,
+  pathArgument
+} from "./check-plan.js"
+
+const compilerFlags = Object.freeze([
+  "--no-default-config", "--driver-mode=g++", "-std=c++20", "-stdlib=libstdc++", "-Wall", "-Wextra", "-Werror",
+  "-pedantic-errors", "-Wconversion", "-Wsign-conversion", "-Wshadow", "-Wformat=2", "-fno-exceptions", "-fno-rtti",
+  "-ftrapv", "-finput-charset=UTF-8", "-fexec-charset=UTF-8", "-fno-color-diagnostics", "-O0"
+])
+
+/**
+ * Constructs C++'s strict Clang C++20/libstdc++ compile/link plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable C++ plan.
+ */
+export function createCppCheckPlan(context) {
+  const tool = checkTool(context, "clangpp", "cpp")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".cpp"), "cpp", "only staged '.cpp' translation units")
+
+  if (artifacts.length != 1 || artifacts[0] != path.join(context.sourcePath, "program.cpp")) {
+    throw new SemantifoldDiagnostic({code: "INVALID_TARGET_CHECK_PLAN", language: "cpp",
+      message: "C++ developer checks require the exact producer-owned 'program.cpp' translation unit."})
+  }
+  const objects = path.join(context.buildPath, "objects")
+  const temporary = path.join(context.buildPath, "tmp")
+  const environment = {TMPDIR: temporary}
+  const environmentPaths = [environmentPath("TMPDIR", "build")]
+  const objectPaths = artifacts.map((_, index) => path.join(objects, `${String(index).padStart(6, "0")}.o`))
+  const stages = artifacts.map((source, index) => {
+    const argv = [...compilerFlags, "-c", source, "-o", objectPaths[index]]
+
+    return checkStage({
+      argv,
+      cwd: context.sourcePath,
+      environment,
+      environmentPaths,
+      inputs: [source],
+      output: null,
+      pathArguments: [pathArgument(argv.length - 3, "source"), pathArgument(argv.length - 1, "build")],
+      stage: /** @type {const} */ ("compile"),
+      tool,
+      transientPaths: [objects]
+    })
+  })
+  const binary = path.join(context.buildPath, "semantifold-cpp")
+  const linkArgv = ["--no-default-config", "--driver-mode=g++", "-stdlib=libstdc++", "-O0", ...objectPaths, "-o", binary]
+
+  stages.push(checkStage({
+    argv: linkArgv,
+    cwd: context.sourcePath,
+    environment,
+    environmentPaths,
+    inputs: objectPaths,
+    output: checkOutput(context.buildPath, "application/x-executable", "linker-output"),
+    pathArguments: [...objectPaths.map((_, index) => pathArgument(index + 4, "build")),
+      pathArgument(linkArgv.length - 1, "build")],
+    stage: "link",
+    tool,
+    transientPaths: [objects]
+  }))
+
+  return checkPlan(context, "cpp", artifacts, stages)
+}

package/src/backends/csharp-check.js

@@ -0,0 +1,139 @@
+// @ts-check
+
+import {createHash} from "node:crypto"
+import path from "node:path"
+import {SemantifoldDiagnostic} from "../diagnostic.js"
+import {
+  checkArtifacts,
+  checkOutput,
+  checkPlan,
+  checkStage,
+  checkTool,
+  environmentPath,
+  pathArgument
+} from "./check-plan.js"
+import {csharpProjectManifest} from "./csharp.js"
+
+/**
+ * Constructs C#'s offline restore and non-executing build plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable C# plan.
+ */
+export function createCSharpCheckPlan(context) {
+  const tool = checkTool(context, "dotnet", "csharp")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".cs") ||
+    artifact.path == "Semantifold.csproj" || artifact.path == "packages.lock.json",
+  "csharp", "only staged C# source and canonical project/lock artifacts")
+  const projects = context.artifacts.artifacts.filter(artifact => artifact.path == "Semantifold.csproj")
+  const sources = artifacts.filter(artifact => artifact.endsWith(".cs"))
+
+  if (projects.length != 1 || projects[0].contentKind != "text" || projects[0].role != "manifest" ||
+    projects[0].content != csharpProjectManifest) {
+    throw new SemantifoldDiagnostic({
+      code: "INVALID_TARGET_CHECK_PLAN",
+      language: "csharp",
+      message: "C# developer checks require the exact producer-owned 'Semantifold.csproj' artifact."
+    })
+  }
+  if (sources.length == 0) {
+    throw new SemantifoldDiagnostic({
+      code: "INVALID_TARGET_CHECK_PLAN",
+      language: "csharp",
+      message: "C# developer checks require at least one staged '.cs' artifact."
+    })
+  }
+  const restoreArtifacts = context.artifacts.artifacts
+    .filter(artifact => artifact.path == "Semantifold.csproj" || artifact.path == "packages.lock.json")
+    .sort((left, right) => left.path.localeCompare(right.path, "en"))
+  const restoreInputs = Object.freeze(restoreArtifacts.map(artifact => path.join(context.sourcePath, artifact.path)))
+  const restoreHash = createHash("sha256")
+
+  for (const artifact of restoreArtifacts) {
+    const contentLength = typeof artifact.content == "string" ? Buffer.byteLength(artifact.content) : artifact.content.byteLength
+
+    restoreHash.update(`${Buffer.byteLength(artifact.path)}:`).update(artifact.path)
+      .update(`${contentLength}:`).update(artifact.content)
+  }
+  const inputHash = restoreHash.digest("hex")
+  const projectPath = path.join(context.sourcePath, projects[0].path)
+  const packages = path.join(context.buildPath, "nuget-packages")
+  const intermediatePath = path.join(context.buildPath, "obj")
+  const intermediate = `${intermediatePath}/`
+  const output = path.join(context.buildPath, "bin")
+  const compileItems = sources.map(source => path.relative(context.sourcePath, source).split(path.sep).join("/")).join("%3B")
+  const isolatedProjectProperties = [
+    "--property:ImportDirectoryBuildProps=false",
+    "--property:ImportDirectoryBuildTargets=false"
+  ]
+  const restoreArgv = [
+    "restore", projectPath, "--source", context.sourcePath, "--packages", packages, "--no-cache", "--force",
+    "--disable-parallel",
+    ...(restoreArtifacts.some(artifact => artifact.path == "packages.lock.json") ? ["--locked-mode"] : []),
+    "--nologo", ...isolatedProjectProperties, `--property:BaseIntermediateOutputPath=${intermediate}`,
+    `--property:MSBuildProjectExtensionsPath=${intermediate}`
+  ]
+  const compileArgv = [
+    "build", projectPath, "--configuration", "Release", "--no-restore", "--nologo", "--warnaserror",
+    "--disable-build-servers", "--output", output, ...isolatedProjectProperties,
+    `--property:SemantifoldCompileItems=${compileItems}`, "--property:UseSharedCompilation=false",
+    `--property:BaseIntermediateOutputPath=${intermediate}`,
+    `--property:MSBuildProjectExtensionsPath=${intermediate}`
+  ]
+  const environment = {
+    DOTNET_CLI_HOME: path.join(context.buildPath, "dotnet-home"),
+    DOTNET_CLI_TELEMETRY_OPTOUT: "1",
+    DOTNET_CLI_USE_MSBUILD_SERVER: "0",
+    DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE: "1",
+    DOTNET_NOLOGO: "1",
+    DOTNET_SKIP_FIRST_TIME_EXPERIENCE: "1",
+    DOTNET_SYSTEM_GLOBALIZATION_INVARIANT: "1",
+    HOME: path.join(context.buildPath, "home"),
+    NUGET_HTTP_CACHE_PATH: path.join(context.buildPath, "nuget-http-cache"),
+    NUGET_PACKAGES: packages,
+    NUGET_PLUGINS_CACHE_PATH: path.join(context.buildPath, "nuget-plugins-cache"),
+    TMPDIR: path.join(context.buildPath, "tmp"),
+    XDG_CACHE_HOME: path.join(context.buildPath, "cache")
+  }
+  const environmentPaths = [
+    environmentPath("DOTNET_CLI_HOME", "build"), environmentPath("HOME", "build"),
+    environmentPath("NUGET_HTTP_CACHE_PATH", "build"), environmentPath("NUGET_PACKAGES", "build"),
+    environmentPath("NUGET_PLUGINS_CACHE_PATH", "build"), environmentPath("TMPDIR", "build"),
+    environmentPath("XDG_CACHE_HOME", "build")
+  ]
+  const ownedOutput = checkOutput(context.buildPath, "application/octet-stream", "compiler-output")
+  const restore = checkStage({
+    argv: restoreArgv,
+    cwd: context.sourcePath,
+    environment,
+    environmentPaths,
+    inputHash,
+    inputs: restoreInputs,
+    output: null,
+    pathArguments: [
+      pathArgument(1, "source"), pathArgument(3, "source"), pathArgument(5, "build"),
+      pathArgument(restoreArgv.length - 2, "build", "--property:BaseIntermediateOutputPath="),
+      pathArgument(restoreArgv.length - 1, "build", "--property:MSBuildProjectExtensionsPath=")
+    ],
+    stage: "restore",
+    tool,
+    transientPaths: [intermediatePath]
+  })
+  const compile = checkStage({
+    argv: compileArgv,
+    cwd: context.sourcePath,
+    environment,
+    environmentPaths,
+    inputs: artifacts,
+    output: ownedOutput,
+    pathArguments: [
+      pathArgument(1, "source"), pathArgument(9, "build"),
+      pathArgument(compileArgv.length - 2, "build", "--property:BaseIntermediateOutputPath="),
+      pathArgument(compileArgv.length - 1, "build", "--property:MSBuildProjectExtensionsPath=")
+    ],
+    stage: "compile",
+    tool,
+    transientPaths: [intermediatePath]
+  })
+
+  return checkPlan(context, "csharp", artifacts, [restore, compile])
+}

package/src/backends/csharp.js

@@ -6,7 +6,7 @@ import {validateBackendModule, emitExpression} from "./shared.js"
 import {emitScalarType} from "./scalars.js"
 import {SourceWriter} from "./writer.js"
 
-const project = `<Project Sdk="Microsoft.NET.Sdk">
+export const csharpProjectManifest = `<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net10.0</TargetFramework>
@@ -25,13 +25,14 @@ const project = `<Project Sdk="Microsoft.NET.Sdk">
     <DebugType>none</DebugType>
     <UseAppHost>false</UseAppHost>
     <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+    <SemantifoldCompileItems Condition="'$(SemantifoldCompileItems)' == ''">Program.cs</SemantifoldCompileItems>
     <AssemblyName>Semantifold</AssemblyName>
     <RootNamespace>Semantifold.Generated</RootNamespace>
     <StartupObject>Semantifold.Generated.Program</StartupObject>
     <PathMap>$(MSBuildProjectDirectory)=/_/</PathMap>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="Program.cs" />
+    <Compile Include="$(SemantifoldCompileItems)" />
   </ItemGroup>
 </Project>
 `
@@ -66,7 +67,7 @@ export function generateCSharpProject({filename, mapDirective, module, sourceMap
       provenance: {kind: "text", mapping, sourceMap: toSourceMapV3(mapping)},
       role: "entry"
     }, {
-      content: project,
+      content: csharpProjectManifest,
       contentKind: "text",
       mediaType: "application/xml",
       ownership: "generated",