semantifold 0.8.0 → 0.10.0

package/src/backends/swift-check.js

@@ -0,0 +1,89 @@
+// @ts-check
+
+import path from "node:path"
+import {SemantifoldDiagnostic} from "../diagnostic.js"
+import {
+  checkArtifacts,
+  checkOutput,
+  checkPlan,
+  checkStage,
+  checkTool,
+  environmentPath,
+  pathArgument
+} from "./check-plan.js"
+
+/**
+ * Constructs Swift's warnings-as-errors type-check/compile plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable Swift plan.
+ */
+export function createSwiftCheckPlan(context) {
+  const tool = checkTool(context, "swiftc", "swift")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".swift"), "swift", "only staged '.swift' sources")
+
+  if (artifacts.length != 1 || artifacts[0] != path.join(context.sourcePath, "program.swift")) {
+    throw new SemantifoldDiagnostic({code: "INVALID_TARGET_CHECK_PLAN", language: "swift",
+      message: "Swift developer checks require the exact producer-owned 'program.swift' source."})
+  }
+  const home = path.join(context.buildPath, "home")
+  const cache = path.join(context.buildPath, "cache")
+  const temporary = path.join(context.buildPath, "tmp")
+  const environment = {
+    HOME: home,
+    PATH: [path.dirname(tool.executable), "/usr/bin", "/usr/local/bin", "/bin"].filter((value, index, values) =>
+      values.indexOf(value) == index).join(path.delimiter),
+    TMPDIR: temporary,
+    XDG_CACHE_HOME: cache
+  }
+  const environmentPaths = [environmentPath("HOME", "build"), environmentPath("TMPDIR", "build"),
+    environmentPath("XDG_CACHE_HOME", "build")]
+  const objects = path.join(context.buildPath, "objects")
+  const object = path.join(objects, "program.o")
+  const binary = path.join(context.buildPath, "semantifold-swift")
+  const typecheckArgv = [
+    "--driver-mode=swiftc", "-warnings-as-errors", "-typecheck", "-module-name", "SemantifoldGenerated", ...artifacts
+  ]
+  const compileArgv = [
+    "--driver-mode=swiftc", "-warnings-as-errors", "-c", ...artifacts,
+    "-module-name", "SemantifoldGenerated", "-o", "program.o"
+  ]
+  const linkArgv = ["--driver-mode=swiftc", object, "-Xlinker", "--build-id=none", "-o", binary]
+
+  return checkPlan(context, "swift", artifacts, [
+    checkStage({
+      argv: typecheckArgv,
+      cwd: context.sourcePath,
+      environment,
+      environmentPaths,
+      inputs: artifacts,
+      output: null,
+      pathArguments: artifacts.map((_, index) => pathArgument(index + 5, "source")),
+      stage: "compile",
+      tool
+    }),
+    checkStage({
+      argv: compileArgv,
+      cwd: objects,
+      environment,
+      environmentPaths,
+      inputs: artifacts,
+      output: null,
+      pathArguments: artifacts.map((_, index) => pathArgument(index + 3, "source")),
+      stage: "compile",
+      tool,
+      transientPaths: [objects]
+    }),
+    checkStage({
+      argv: linkArgv,
+      cwd: context.buildPath,
+      environment,
+      environmentPaths,
+      inputs: [object],
+      output: checkOutput(context.buildPath, "application/x-executable", "compiler-output"),
+      pathArguments: [pathArgument(1, "build"), pathArgument(linkArgv.length - 1, "build")],
+      stage: "compile",
+      tool,
+      transientPaths: [objects]
+    })
+  ])
+}

package/src/backends/typescript-check.js

@@ -0,0 +1,37 @@
+// @ts-check
+
+import path from "node:path"
+import {SemantifoldDiagnostic} from "../diagnostic.js"
+import {checkArtifacts, checkPlan, checkStage, checkTool, pathArgument} from "./check-plan.js"
+
+/**
+ * Constructs TypeScript's non-emitting compiler plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable TypeScript plan.
+ */
+export function createTypeScriptCheckPlan(context) {
+  const tool = checkTool(context, "tsc", "typescript")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".ts") || path.basename(artifact.path) == "package.json",
+    "typescript", "only staged '.ts' artifacts and package manifests")
+  const sources = artifacts.filter(artifact => artifact.endsWith(".ts"))
+
+  if (sources.length == 0) {
+    throw new SemantifoldDiagnostic({code: "INVALID_TARGET_CHECK_PLAN", language: "typescript",
+      message: "TypeScript developer checks require at least one staged '.ts' artifact."})
+  }
+  const typeRoots = path.join(context.buildPath, "types")
+  const argv = [
+    "--pretty", "false", "--noEmit", "--incremental", "false", "--target", "ES2024", "--module", "NodeNext",
+    "--moduleResolution", "NodeNext", "--typeRoots", typeRoots, ...sources
+  ]
+
+  return checkPlan(context, "typescript", artifacts, [checkStage({
+    argv,
+    cwd: context.sourcePath,
+    inputs: artifacts,
+    output: null,
+    pathArguments: [pathArgument(12, "build"), ...sources.map((_, index) => pathArgument(13 + index, "source"))],
+    stage: "compile",
+    tool
+  })])
+}

package/src/backends/zig-check.js

@@ -0,0 +1,81 @@
+// @ts-check
+
+import path from "node:path"
+import {SemantifoldDiagnostic} from "../diagnostic.js"
+import {
+  checkArtifacts,
+  checkPlan,
+  checkStage,
+  checkTool,
+  environmentPath,
+  pathArgument
+} from "./check-plan.js"
+import {zigBuild} from "./zig-runtime.js"
+
+/**
+ * Constructs Zig's isolated Debug project build and canonical format-check plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable Zig plan.
+ */
+export function createZigCheckPlan(context) {
+  const tool = checkTool(context, "zig", "zig")
+  const artifacts = checkArtifacts(context, artifact => artifact.path == "build.zig" || artifact.path.endsWith(".zig"),
+    "zig", "only staged Zig source and the canonical build manifest")
+  const manifests = context.artifacts.artifacts.filter(artifact => artifact.path == "build.zig")
+  const sources = artifacts.filter(artifact => artifact != path.join(context.sourcePath, "build.zig"))
+
+  if (manifests.length != 1 || manifests[0].contentKind != "text" || manifests[0].role != "manifest" ||
+    manifests[0].content != zigBuild || artifacts.length != 2 || sources.length != 1 ||
+    sources[0] != path.join(context.sourcePath, "src/main.zig")) {
+    throw new SemantifoldDiagnostic({
+      code: "INVALID_TARGET_CHECK_PLAN",
+      language: "zig",
+      message: "Zig developer checks require the exact standard-library-only 'build.zig' and staged Zig source."
+    })
+  }
+  const home = path.join(context.buildPath, "home")
+  const temporary = path.join(context.buildPath, "tmp")
+  const globalCache = path.join(context.buildPath, "zig-global-cache")
+  const localCache = path.join(context.buildPath, "zig-local-cache")
+  const output = path.join(context.buildPath, "output")
+  const environment = {
+    HOME: home,
+    HTTP_PROXY: "http://127.0.0.1:9",
+    HTTPS_PROXY: "http://127.0.0.1:9",
+    NO_PROXY: "",
+    TMPDIR: temporary,
+    ZIG_GLOBAL_CACHE_DIR: globalCache,
+    ZIG_LOCAL_CACHE_DIR: localCache
+  }
+  const environmentPaths = [
+    environmentPath("HOME", "build"), environmentPath("TMPDIR", "build"),
+    environmentPath("ZIG_GLOBAL_CACHE_DIR", "build"), environmentPath("ZIG_LOCAL_CACHE_DIR", "build")
+  ]
+  const formatArgv = ["fmt", "--check", ...artifacts]
+
+  return checkPlan(context, "zig", artifacts, [
+    checkStage({
+      argv: ["build", "-Doptimize=Debug", "--prefix", output],
+      cwd: context.sourcePath,
+      environment,
+      environmentPaths,
+      inputs: artifacts,
+      output: null,
+      pathArguments: [pathArgument(3, "build")],
+      stage: "compile",
+      tool,
+      transientPaths: [output]
+    }),
+    checkStage({
+      argv: formatArgv,
+      cwd: context.sourcePath,
+      environment,
+      environmentPaths,
+      inputs: artifacts,
+      output: null,
+      pathArguments: artifacts.map((_, index) => pathArgument(index + 2, "source")),
+      stage: "validate",
+      tool
+    })
+  ])
+}

package/src/diagnostic.js

@@ -19,8 +19,12 @@ export class SemantifoldDiagnostic extends Error {
    * @param {string | undefined} [options.stderr] - Captured standard error when available.
    * @param {string | undefined} [options.stdout] - Captured standard output when available.
    * @param {string | undefined} [options.version] - Captured executable version when known.
+   * @param {number | undefined} [options.durationMs] - Observed process duration when known.
+   * @param {string | undefined} [options.projectId] - Exact project identity when known.
+   * @param {string | undefined} [options.targetId] - Exact project target identity when known.
+   * @param {string | undefined} [options.toolId] - Exact toolchain identity when known.
    */
-  constructor({cause, code, command, executable, exitCode, generatedLocation, language, location, message, signal, stage, stderr, stdout, version}) {
+  constructor({cause, code, command, durationMs, executable, exitCode, generatedLocation, language, location, message, projectId, signal, stage, stderr, stdout, targetId, toolId, version}) {
     const locationText = location ? ` at ${location.filename}:${location.start.line}:${location.start.column}` : ""
 
     super(`[${code}] ${language}${locationText}: ${message}`, cause ? {cause} : undefined)
@@ -31,12 +35,16 @@ export class SemantifoldDiagnostic extends Error {
     this.language = language
     this.location = location
     if (command != undefined) this.command = command
+    if (durationMs != undefined) this.durationMs = durationMs
     if (executable != undefined) this.executable = executable
     if (exitCode != undefined) this.exitCode = exitCode
     if (signal != undefined) this.signal = signal
     if (stage != undefined) this.stage = stage
     if (stderr != undefined) this.stderr = stderr
     if (stdout != undefined) this.stdout = stdout
+    if (projectId != undefined) this.projectId = projectId
+    if (targetId != undefined) this.targetId = targetId
+    if (toolId != undefined) this.toolId = toolId
     if (version != undefined) this.version = version
   }
 }

package/src/frontends/program.js

@@ -19,6 +19,15 @@ import {inspectRubyModule} from "./ruby.js"
 const programLanguages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const moduleIdPattern = /^[a-z][a-z0-9_]*(?:[.-][a-z][a-z0-9_]*)*$/u
 
+/**
+ * Reports whether a registered frontend participates in the explicit Task-010 program profile.
+ * @param {string} language - Registered source identity.
+ * @returns {boolean} Whether the profile accepts the language.
+ */
+export function supportsProgramSourceLanguage(language) {
+  return programLanguages.has(/** @type {import("../semantic/types.js").SemanticLanguage} */ (language))
+}
+
 /** @typedef {{facade?: import("../stdlib-facades.js").StdlibFacadeRecord, filename: string, id: string, language: import("../semantic/types.js").SemanticLanguage, ownership: "application" | "facade", source: string}} ProgramSource */
 /** @typedef {{declarationLocation?: import("../semantic/types.js").SourceLocation, facade?: import("../stdlib-facades.js").StdlibFacadeRecord, importedName: string, importedNameLocation?: import("../semantic/types.js").SourceLocation, localName: string, localNameLocation?: import("../semantic/types.js").SourceLocation, location: import("../semantic/types.js").SourceLocation, namespace?: boolean, pathLocation: import("../semantic/types.js").SourceLocation, specifier: string, stdlibCandidate?: true, typeOnly: boolean}} ProgramImportRequest */
 /** @typedef {{importedName: string, localName: string, location: import("../semantic/types.js").SourceLocation, nativeName: string, symbolKind: import("../semantic/types.js").SemanticDeclarationKind, typeOnly: boolean}} ProgramNativeBinding */

package/src/language-registry.js

@@ -5,6 +5,7 @@ import {SemantifoldDiagnostic, unsupportedRole} from "./diagnostic.js"
 import {generateJava} from "./backends/java.js"
 import {generateKotlin} from "./backends/kotlin.js"
 import {generateCSharpProject} from "./backends/csharp.js"
+import {createCSharpCheckPlan} from "./backends/csharp-check.js"
 import {generateGoModule} from "./backends/go.js"
 import {generateRustProject} from "./backends/rust.js"
 import {generateSwift} from "./backends/swift.js"
@@ -35,12 +36,27 @@ import {parseJavaScriptTypeScript} from "./frontends/javascript-typescript.js"
 import {parsePhp} from "./frontends/php.js"
 import {parsePython} from "./frontends/python.js"
 import {parseRuby} from "./frontends/ruby.js"
+import {createJavaCheckPlan} from "./backends/java-check.js"
+import {createJavaScriptCheckPlan} from "./backends/javascript-check.js"
+import {createKotlinCheckPlan} from "./backends/kotlin-check.js"
+import {createPhpCheckPlan} from "./backends/php-check.js"
+import {createPythonCheckPlan} from "./backends/python-check.js"
+import {createRubyCheckPlan} from "./backends/ruby-check.js"
+import {createTypeScriptCheckPlan} from "./backends/typescript-check.js"
+import {createGoCheckPlan} from "./backends/go-check.js"
+import {createCCheckPlan} from "./backends/c-check.js"
+import {createCppCheckPlan} from "./backends/cpp-check.js"
+import {createRustCheckPlan} from "./backends/rust-check.js"
+import {createSwiftCheckPlan} from "./backends/swift-check.js"
+import {createDartCheckPlan} from "./backends/dart-check.js"
+import {createZigCheckPlan} from "./backends/zig-check.js"
 
 const registryRoles = Object.freeze(["frontend", "textBackend", "binaryBackend", "applicationBackend", "interoperability"])
 const acceptanceStageOrder = ["parse", "generate", "restore", "compile", "link", "validate", "instantiate", "execute"]
 const acceptanceStages = new Map(acceptanceStageOrder.map((stage, index) => [stage, index]))
+const developerCheckStages = new Set(["restore", "compile", "link", "validate"])
 const registryKeys = new Set([
-  "acceptance", "applicationBackend", "artifactMultiplicity", "binaryBackend", "defaultFilename", "frontend", "id",
+  "acceptance", "applicationBackend", "artifactMultiplicity", "binaryBackend", "check", "defaultFilename", "frontend", "id",
   "features", "interoperability", "mapping", "mediaType", "provider", "roundTrip", "textBackend"
 ])
 
@@ -65,6 +81,7 @@ const registryKeys = new Set([
  * @typedef LanguageRegistryRecord
  * @property {string} id - Stable identity.
  * @property {{stages: import("./semantic/types.js").AcceptanceStage[], toolchains: string[]}} acceptance - Acceptance declaration.
+ * @property {Readonly<LanguageRegistryCheckRecord>} check - Developer-check declaration.
  * @property {"single" | "multiple"} artifactMultiplicity - Artifact multiplicity.
  * @property {import("./semantic/types.js").LanguageFeatureCapabilities} features - Semantic feature capabilities.
  * @property {import("./semantic/types.js").LanguageMappingCapabilities} mapping - Mapping capabilities.
@@ -79,6 +96,31 @@ const registryKeys = new Set([
  * @property {RegistryImplementation} [interoperability] - Interoperability bridge.
  */
 
+/**
+ * @typedef {Readonly<{
+ *   artifacts: import("./semantic/types.js").GeneratedArtifactSet,
+ *   buildPath: string,
+ *   projectId: string,
+ *   sourcePath: string,
+ *   targetId: string,
+ *   tools: readonly import("./semantic/types.js").DiscoveredToolchain[]
+ * }>} TargetCheckPlanContext
+ */
+
+/**
+ * @callback TargetCheckPlanFactory
+ * @param {TargetCheckPlanContext} context - Exact staged target context.
+ * @returns {import("./semantic/types.js").TargetCheckPlan} Immutable plan.
+ */
+
+/**
+ * @typedef LanguageRegistryCheckRecord
+ * @property {TargetCheckPlanFactory} [factory] - Target-owned plan factory for supported checks.
+ * @property {readonly import("./semantic/types.js").AcceptanceStage[]} stages - Exact non-executing stages.
+ * @property {boolean} supported - Whether the target supplies a check plan.
+ * @property {readonly string[]} toolchains - Exact declared canonical toolchains.
+ */
+
 /**
  * @typedef LanguageRegistry
  * @property {readonly import("./semantic/types.js").LanguageCapabilities[]} descriptors - Public descriptors.
@@ -218,6 +260,52 @@ export function createLanguageRegistry(candidateRecords) {
     if (new Set(toolchains).size != toolchains.length) {
       invalidRegistry(`Registry record '${id}' has duplicate acceptance toolchains.`, id)
     }
+    const checkCandidate = candidate.check
+    /** @type {Readonly<LanguageRegistryCheckRecord>} */
+    let check
+
+    if (checkCandidate === undefined) {
+      check = deepFreeze({stages: [], supported: false, toolchains: []})
+    } else {
+      if (!isPlainObject(checkCandidate) || Object.keys(checkCandidate).sort().join(",") != "factory,stages,toolchains" ||
+        typeof checkCandidate.factory != "function" || !isDenseArray(checkCandidate.stages) ||
+        !isDenseArray(checkCandidate.toolchains) || checkCandidate.stages.length == 0) {
+        invalidRegistry(`Registry record '${id}' has an invalid developer-check declaration.`, id)
+      }
+      /** @type {unknown[]} */
+      const checkStageSnapshot = []
+      /** @type {unknown[]} */
+      const checkToolchainSnapshot = []
+
+      for (let index = 0; index < checkCandidate.stages.length; index += 1) {
+        checkStageSnapshot.push(checkCandidate.stages[index])
+      }
+      for (let index = 0; index < checkCandidate.toolchains.length; index += 1) {
+        checkToolchainSnapshot.push(checkCandidate.toolchains[index])
+      }
+      if (!checkStageSnapshot.every(stage => typeof stage == "string" && developerCheckStages.has(stage) &&
+        declaredStages.has(stage)) || !checkToolchainSnapshot.every(toolchain => typeof toolchain == "string" &&
+        toolchains.includes(toolchain)) || new Set(checkStageSnapshot).size != checkStageSnapshot.length ||
+        new Set(checkToolchainSnapshot).size != checkToolchainSnapshot.length) {
+        invalidRegistry(`Registry record '${id}' developer checks must use ordered non-executing declared stages and toolchains.`, id)
+      }
+      let previousCheckStage = -1
+
+      for (const stage of checkStageSnapshot) {
+        const stageIndex = /** @type {number} */ (acceptanceStages.get(/** @type {string} */ (stage)))
+
+        if (stageIndex < previousCheckStage) {
+          invalidRegistry(`Registry record '${id}' has unordered developer-check stages.`, id)
+        }
+        previousCheckStage = stageIndex
+      }
+      check = deepFreeze({
+        factory: /** @type {TargetCheckPlanFactory} */ (checkCandidate.factory),
+        stages: /** @type {import("./semantic/types.js").AcceptanceStage[]} */ (checkStageSnapshot),
+        supported: true,
+        toolchains: /** @type {string[]} */ (checkToolchainSnapshot)
+      })
+    }
 
     const hasFrontend = typeof candidate.frontend == "function"
     const hasTextBackend = typeof candidate.textBackend == "function"
@@ -225,6 +313,10 @@ export function createLanguageRegistry(candidateRecords) {
     const hasApplicationBackend = typeof candidate.applicationBackend == "function"
     const hasBackend = hasTextBackend || hasBinaryBackend || hasApplicationBackend
 
+    if (check.supported && !hasBackend) {
+      invalidRegistry(`Registry record '${id}' declares developer checks without a backend role.`, id)
+    }
+
     if ((mapping.richText || mapping.sourceMapV3 || mapping.binaryRanges) && !hasBackend ||
       mapping.sourceMapV3 && !mapping.richText ||
       mapping.binaryRanges && !hasBinaryBackend && !hasApplicationBackend) {
@@ -255,6 +347,7 @@ export function createLanguageRegistry(candidateRecords) {
     const record = deepFreeze(/** @type {LanguageRegistryRecord} */ ({
       acceptance,
       artifactMultiplicity,
+      check,
       features,
       id,
       mapping,
@@ -271,6 +364,7 @@ export function createLanguageRegistry(candidateRecords) {
     const descriptor = deepFreeze(/** @type {import("./semantic/types.js").LanguageCapabilities} */ ({
       acceptance,
       artifactMultiplicity,
+      check: deepFreeze({stages: check.stages, supported: check.supported, toolchains: check.toolchains}),
       features,
       id,
       mapping,
@@ -384,7 +478,8 @@ const zigFrontend = ({filename, source}) => parseZig({filename, source})
 
 const records = [
   language({
-    acceptance: {stages: ["parse", "generate", "execute"], toolchains: ["php82"]},
+    acceptance: {stages: ["parse", "generate", "validate", "execute"], toolchains: ["php82"]},
+    check: {factory: createPhpCheckPlan, stages: ["validate"], toolchains: ["php82"]},
     defaultFilename: "program.php",
     frontend: phpFrontend,
     id: "php",
@@ -392,7 +487,8 @@ const records = [
     textBackend: generatePhp
   }),
   language({
-    acceptance: {stages: ["parse", "generate", "execute"], toolchains: ["ruby"]},
+    acceptance: {stages: ["parse", "generate", "validate", "execute"], toolchains: ["ruby"]},
+    check: {factory: createRubyCheckPlan, stages: ["validate"], toolchains: ["ruby"]},
     defaultFilename: "program.rb",
     frontend: rubyFrontend,
     id: "ruby",
@@ -400,7 +496,8 @@ const records = [
     textBackend: generateRuby
   }),
   language({
-    acceptance: {stages: ["parse", "generate", "execute"], toolchains: ["node"]},
+    acceptance: {stages: ["parse", "generate", "validate", "execute"], toolchains: ["node"]},
+    check: {factory: createJavaScriptCheckPlan, stages: ["validate"], toolchains: ["node"]},
     defaultFilename: "program.js",
     frontend: javaScriptFrontend,
     id: "javascript",
@@ -409,6 +506,7 @@ const records = [
   }),
   language({
     acceptance: {stages: ["parse", "generate", "compile", "execute"], toolchains: ["tsc", "node"]},
+    check: {factory: createTypeScriptCheckPlan, stages: ["compile"], toolchains: ["tsc"]},
     defaultFilename: "program.ts",
     frontend: typeScriptFrontend,
     id: "typescript",
@@ -417,6 +515,7 @@ const records = [
   }),
   language({
     acceptance: {stages: ["parse", "generate", "compile", "execute"], toolchains: ["javac", "java"]},
+    check: {factory: createJavaCheckPlan, stages: ["compile"], toolchains: ["javac"]},
     defaultFilename: "Main.java",
     frontend: javaFrontend,
     id: "java",
@@ -425,6 +524,7 @@ const records = [
   }),
   language({
     acceptance: {stages: ["parse", "generate", "compile", "execute"], toolchains: ["kotlinc", "java25"]},
+    check: {factory: createKotlinCheckPlan, stages: ["compile"], toolchains: ["kotlinc"]},
     defaultFilename: "Program.kt",
     frontend: kotlinFrontend,
     id: "kotlin",
@@ -433,6 +533,7 @@ const records = [
   }),
   language({
     acceptance: {stages: ["parse", "generate", "compile", "execute"], toolchains: ["python"]},
+    check: {factory: createPythonCheckPlan, stages: ["compile"], toolchains: ["python"]},
     defaultFilename: "program.py",
     frontend: pythonFrontend,
     id: "python",
@@ -442,6 +543,7 @@ const records = [
   language({
     acceptance: {stages: ["parse", "generate", "restore", "compile", "execute"], toolchains: ["dotnet"]},
     artifactMultiplicity: "multiple",
+    check: {factory: createCSharpCheckPlan, stages: ["restore", "compile"], toolchains: ["dotnet"]},
     defaultFilename: "Program.cs",
     frontend: csharpFrontend,
     id: "csharp",
@@ -451,6 +553,7 @@ const records = [
   language({
     acceptance: {stages: ["parse", "generate", "compile", "validate", "execute"], toolchains: ["go"]},
     artifactMultiplicity: "multiple",
+    check: {factory: createGoCheckPlan, stages: ["compile", "validate"], toolchains: ["go"]},
     defaultFilename: "main.go",
     frontend: goFrontend,
     id: "go",
@@ -460,6 +563,7 @@ const records = [
   language({
     acceptance: {stages: ["parse", "generate", "compile", "link", "execute"], toolchains: ["clang"]},
     artifactMultiplicity: "multiple",
+    check: {factory: createCCheckPlan, stages: ["compile", "link"], toolchains: ["clang"]},
     defaultFilename: "program.c",
     frontend: parseC,
     id: "c",
@@ -468,18 +572,22 @@ const records = [
   }),
   language({
     acceptance: {stages: ["parse", "generate", "compile", "link", "execute"], toolchains: ["clangpp"]},
+    check: {factory: createCppCheckPlan, stages: ["compile", "link"], toolchains: ["clangpp"]},
     defaultFilename: "program.cpp", frontend: parseCpp, id: "cpp", mediaType: "text/x-c++src", textBackend: generateCpp
   }),
   language({
     acceptance: {stages: ["parse", "generate", "compile", "validate", "execute"], toolchains: ["rustc", "cargo"]},
     artifactMultiplicity: "multiple",
+    check: {factory: createRustCheckPlan, stages: ["compile", "validate"], toolchains: ["rustc", "cargo"]},
     defaultFilename: "src/main.rs", frontend: parseRust, id: "rust", mediaType: "text/x-rust", textBackend: generateRustProject
   }),
   language({acceptance: {stages: ["parse", "generate", "compile", "execute"], toolchains: ["swiftc"]},
+    check: {factory: createSwiftCheckPlan, stages: ["compile"], toolchains: ["swiftc"]},
     defaultFilename: "program.swift", frontend: parseSwift, id: "swift", mediaType: "text/x-swift", textBackend: generateSwift}),
   language({
     acceptance: {stages: ["parse", "generate", "restore", "compile", "validate", "execute"], toolchains: ["dart"]},
     artifactMultiplicity: "multiple",
+    check: {factory: createDartCheckPlan, stages: ["restore", "compile", "validate"], toolchains: ["dart"]},
     defaultFilename: "bin/program.dart",
     features: {
       closedRecords: false,
@@ -502,6 +610,7 @@ const records = [
   language({
     acceptance: {stages: ["parse", "generate", "compile", "validate", "execute"], toolchains: ["zig"]},
     artifactMultiplicity: "multiple",
+    check: {factory: createZigCheckPlan, stages: ["compile", "validate"], toolchains: ["zig"]},
     defaultFilename: "src/main.zig",
     features: {
       closedRecords: false,