semantifold 0.8.0 → 0.10.0

package/src/backends/dart-check.js

@@ -0,0 +1,117 @@
+// @ts-check
+
+import {createHash} from "node:crypto"
+import path from "node:path"
+import {SemantifoldDiagnostic} from "../diagnostic.js"
+import {
+  checkArtifacts,
+  checkPlan,
+  checkStage,
+  checkTool,
+  environmentPath,
+  pathArgument
+} from "./check-plan.js"
+import {dartLockfile, dartPubspec} from "./dart.js"
+
+/**
+ * Constructs Dart's offline package verification, native compile, format and analysis plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable Dart plan.
+ */
+export function createDartCheckPlan(context) {
+  const tool = checkTool(context, "dart", "dart")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".dart") ||
+    artifact.path == "pubspec.yaml" || artifact.path == "pubspec.lock",
+  "dart", "only staged Dart source and canonical pub package/lock artifacts")
+  const pubspecs = context.artifacts.artifacts.filter(artifact => artifact.path == "pubspec.yaml")
+  const lockfiles = context.artifacts.artifacts.filter(artifact => artifact.path == "pubspec.lock")
+  const sources = artifacts.filter(artifact => artifact.endsWith(".dart"))
+
+  if (pubspecs.length != 1 || pubspecs[0].contentKind != "text" || pubspecs[0].role != "manifest" ||
+    pubspecs[0].content != dartPubspec || lockfiles.length != 1 || lockfiles[0].contentKind != "text" ||
+    lockfiles[0].role != "manifest" || lockfiles[0].content != dartLockfile || artifacts.length != 3 || sources.length != 1 ||
+    sources[0] != path.join(context.sourcePath, "bin/program.dart")) {
+    throw new SemantifoldDiagnostic({
+      code: "INVALID_TARGET_CHECK_PLAN",
+      language: "dart",
+      message: "Dart developer checks require the exact dependency-free pub package/lock and staged '.dart' source."
+    })
+  }
+  const restoreArtifacts = context.artifacts.artifacts.filter(artifact =>
+    artifact.path == "pubspec.yaml" || artifact.path == "pubspec.lock").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 home = path.join(context.buildPath, "home")
+  const pubCache = path.join(context.buildPath, "pub-cache")
+  const temporary = path.join(context.buildPath, "tmp")
+  const environment = {
+    CI: "true",
+    DART_SUPPRESS_ANALYTICS: "true",
+    HOME: home,
+    PUB_CACHE: pubCache,
+    PUB_HOSTED_URL: "http://127.0.0.1:9",
+    TMPDIR: temporary
+  }
+  const environmentPaths = [environmentPath("HOME", "build"), environmentPath("PUB_CACHE", "build"),
+    environmentPath("TMPDIR", "build")]
+  const nativeOutput = path.join(context.buildPath, "native-output")
+  const binary = path.join(nativeOutput, "semantifold-dart")
+  const compileArgv = ["compile", "exe", sources[0], "-o", binary]
+
+  return checkPlan(context, "dart", artifacts, [
+    checkStage({
+      argv: ["pub", "get", "--offline", "--dry-run", "--enforce-lockfile", "--no-precompile"],
+      cwd: context.sourcePath,
+      environment,
+      environmentPaths,
+      inputHash: restoreHash.digest("hex"),
+      inputs: restoreInputs,
+      output: null,
+      pathArguments: [],
+      stage: "restore",
+      tool,
+      transientPaths: [path.join(context.sourcePath, ".dart_tool")]
+    }),
+    checkStage({
+      argv: compileArgv,
+      cwd: context.sourcePath,
+      environment,
+      environmentPaths,
+      inputs: artifacts,
+      output: null,
+      pathArguments: [pathArgument(2, "source"), pathArgument(4, "build")],
+      stage: "compile",
+      tool,
+      transientPaths: [nativeOutput]
+    }),
+    checkStage({
+      argv: ["format", "--output=none", "--set-exit-if-changed", sources[0]],
+      cwd: context.sourcePath,
+      environment,
+      environmentPaths,
+      inputs: sources,
+      output: null,
+      pathArguments: [pathArgument(3, "source")],
+      stage: "validate",
+      tool
+    }),
+    checkStage({
+      argv: ["analyze", "--fatal-infos", "--fatal-warnings", context.sourcePath],
+      cwd: context.sourcePath,
+      environment,
+      environmentPaths,
+      inputs: artifacts,
+      output: null,
+      pathArguments: [pathArgument(3, "source")],
+      stage: "validate",
+      tool
+    })
+  ])
+}

package/src/backends/dart.js

@@ -7,8 +7,8 @@ import {dartRuntime} from "./dart-runtime.js"
 import {emitScalarType} from "./scalars.js"
 import {SourceWriter} from "./writer.js"
 
-const pubspec = "name: semantifold_generated\npublish_to: none\nenvironment:\n  sdk: 3.13.3\n"
-const lockfile = "# Generated by pub\n# See https://dart.dev/tools/pub/glossary#lockfile\npackages: {}\nsdks:\n  dart: \"3.13.3\"\n"
+export const dartPubspec = "name: semantifold_generated\npublish_to: none\nenvironment:\n  sdk: 3.13.3\n"
+export const dartLockfile = "# Generated by pub\n# See https://dart.dev/tools/pub/glossary#lockfile\npackages: {}\nsdks:\n  dart: \"3.13.3\"\n"
 
 /**
  * Emits one deterministic dependency-free Dart package candidate.
@@ -35,7 +35,7 @@ export function generateDartPackage({filename, mapDirective, module, sourceMapFi
 
   return {
     artifacts: [{
-      content: pubspec,
+      content: dartPubspec,
       contentKind: "text",
       mediaType: "application/yaml",
       ownership: "generated",
@@ -47,7 +47,7 @@ export function generateDartPackage({filename, mapDirective, module, sourceMapFi
       },
       role: "manifest"
     }, {
-      content: lockfile,
+      content: dartLockfile,
       contentKind: "text",
       mediaType: "application/yaml",
       ownership: "generated",

package/src/backends/go-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"
+import {goModuleManifest} from "./go.js"
+
+/**
+ * Constructs Go's cgo-disabled, offline build/vet plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable Go plan.
+ */
+export function createGoCheckPlan(context) {
+  const tool = checkTool(context, "go", "go")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".go") || artifact.path == "go.mod",
+    "go", "only staged '.go' sources and the canonical module manifest")
+  const manifests = context.artifacts.artifacts.filter(artifact => artifact.path == "go.mod")
+  const sources = artifacts.filter(artifact => artifact.endsWith(".go"))
+
+  if (manifests.length != 1 || manifests[0].contentKind != "text" || manifests[0].role != "manifest" ||
+    manifests[0].content != goModuleManifest || artifacts.length != 2 || sources.length != 1 ||
+    sources[0] != path.join(context.sourcePath, "main.go")) {
+    throw new SemantifoldDiagnostic({
+      code: "INVALID_TARGET_CHECK_PLAN",
+      language: "go",
+      message: "Go developer checks require the exact dependency-free 'go.mod' and at least one staged '.go' source."
+    })
+  }
+  const cache = path.join(context.buildPath, "go-cache")
+  const moduleCache = path.join(context.buildPath, "go-mod-cache")
+  const goPath = path.join(context.buildPath, "go-path")
+  const temporary = path.join(context.buildPath, "go-tmp")
+  const home = path.join(context.buildPath, "go-home")
+  const binary = path.join(context.buildPath, "semantifold-go")
+  const environment = {
+    CGO_ENABLED: "0",
+    GOARCH: "amd64",
+    GOCACHE: cache,
+    GOENV: "off",
+    GOMODCACHE: moduleCache,
+    GOOS: "linux",
+    GOPATH: goPath,
+    GOPROXY: "off",
+    GOSUMDB: "off",
+    GOTOOLCHAIN: "local",
+    GOTMPDIR: temporary,
+    GOVCS: "off",
+    GOWORK: "off",
+    GO_TELEMETRY_CHILD: "2",
+    HOME: home
+  }
+  const environmentPaths = [
+    environmentPath("GOCACHE", "build"), environmentPath("GOMODCACHE", "build"), environmentPath("GOPATH", "build"),
+    environmentPath("GOTMPDIR", "build"), environmentPath("HOME", "build")
+  ]
+
+  return checkPlan(context, "go", artifacts, [
+    checkStage({
+      argv: ["build", "-mod=readonly", "-trimpath", "-buildvcs=false", "-ldflags=-buildid=", "-o", binary, "."],
+      cwd: context.sourcePath,
+      environment,
+      environmentPaths,
+      inputs: artifacts,
+      output: checkOutput(context.buildPath, "application/x-executable", "compiler-output"),
+      pathArguments: [pathArgument(6, "build")],
+      stage: "compile",
+      tool
+    }),
+    checkStage({
+      argv: ["vet", "-mod=readonly", "."],
+      cwd: context.sourcePath,
+      environment,
+      environmentPaths,
+      inputs: artifacts,
+      output: null,
+      pathArguments: [],
+      stage: "validate",
+      tool
+    })
+  ])
+}

package/src/backends/go.js

@@ -6,7 +6,7 @@ import {validateBackendModule, emitExpression} from "./shared.js"
 import {emitScalarType} from "./scalars.js"
 import {SourceWriter} from "./writer.js"
 
-const manifest = "module example.com/semantifold/generated\n\ngo 1.26.0\n"
+export const goModuleManifest = "module example.com/semantifold/generated\n\ngo 1.26.0\n"
 const binarySyntax = Object.freeze({
   BooleanAnd: "&&", BooleanEqual: "==", BooleanNotEqual: "!=", BooleanOr: "||",
   IntegerAdd: "+", IntegerEqual: "==", IntegerGreaterThan: ">", IntegerGreaterThanOrEqual: ">=",
@@ -38,7 +38,7 @@ export function generateGoModule({filename, mapDirective, module, sourceMapFilen
   if (!root) throw new Error("Validated Go module omitted its canonical root provenance.")
   return {
     artifacts: [{
-      content: manifest,
+      content: goModuleManifest,
       contentKind: "text",
       mediaType: "text/plain",
       ownership: "generated",

package/src/backends/java-check.js

@@ -0,0 +1,77 @@
+// @ts-check
+
+import path from "node:path"
+import {SemantifoldDiagnostic} from "../diagnostic.js"
+import {deterministicEnvironment} from "../toolchains.js"
+
+/**
+ * Constructs Java's non-executing compiler plan from staged generated artifacts.
+ * @param {Readonly<{
+ *   artifacts: import("../semantic/types.js").GeneratedArtifactSet,
+ *   buildPath: string,
+ *   projectId: string,
+ *   sourcePath: string,
+ *   targetId: string,
+ *   tools: readonly import("../semantic/types.js").DiscoveredToolchain[]
+ * }>} context - Exact validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable javac plan.
+ */
+export function createJavaCheckPlan(context) {
+  const javac = context.tools.find(({id}) => id == "javac")
+
+  if (!javac) {
+    throw new SemantifoldDiagnostic({
+      code: "INVALID_TARGET_CHECK_PLAN",
+      language: "java",
+      message: "Java developer checks require the declared 'javac' toolchain."
+    })
+  }
+  const artifactPaths = context.artifacts.artifacts
+    .filter(artifact => artifact.path.endsWith(".java"))
+    .map(artifact => path.join(context.sourcePath, artifact.path))
+
+  if (artifactPaths.length == 0) {
+    throw new SemantifoldDiagnostic({
+      code: "INVALID_TARGET_CHECK_PLAN",
+      language: "java",
+      message: "Java developer checks require at least one staged '.java' artifact."
+    })
+  }
+  const argv = Object.freeze(["-d", context.buildPath, ...artifactPaths])
+  const pathArguments = Object.freeze([
+    Object.freeze({index: 1, ownership: /** @type {const} */ ("build")}),
+    ...artifactPaths.map((_, index) => Object.freeze({index: index + 2, ownership: /** @type {const} */ ("source")}))
+  ])
+  const stage = Object.freeze({
+    argv,
+    cwd: context.sourcePath,
+    environment: deterministicEnvironment({}),
+    environmentPaths: Object.freeze([]),
+    executable: javac.executable,
+    inputHash: null,
+    inputs: Object.freeze(artifactPaths),
+    output: Object.freeze({
+      mediaType: "application/java-vm",
+      ownership: /** @type {const} */ ("build"),
+      path: context.buildPath,
+      role: "compiler-output"
+    }),
+    pathArguments,
+    stage: /** @type {const} */ ("compile"),
+    tool: javac,
+    transientPaths: Object.freeze([])
+  })
+
+  return Object.freeze({
+    artifactPaths: Object.freeze(artifactPaths),
+    buildPath: context.buildPath,
+    mode: /** @type {const} */ ("developer-check"),
+    projectId: context.projectId,
+    schema: /** @type {const} */ ("SemantifoldTargetCheckPlan"),
+    sourcePath: context.sourcePath,
+    stages: Object.freeze([stage]),
+    target: "java",
+    targetId: context.targetId,
+    version: /** @type {const} */ (1)
+  })
+}

package/src/backends/javascript-check.js

@@ -0,0 +1,33 @@
+// @ts-check
+
+import path from "node:path"
+import {checkArtifacts, checkPlan, checkStage, checkTool, pathArgument} from "./check-plan.js"
+import {SemantifoldDiagnostic} from "../diagnostic.js"
+
+/**
+ * Constructs JavaScript's non-executing parse-check plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable JavaScript plan.
+ */
+export function createJavaScriptCheckPlan(context) {
+  const tool = checkTool(context, "node", "javascript")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".js") || path.basename(artifact.path) == "package.json",
+    "javascript", "only staged '.js' artifacts and package manifests")
+  const sources = artifacts.filter(artifact => artifact.endsWith(".js"))
+  const manifests = artifacts.filter(artifact => artifact.endsWith("package.json"))
+
+  if (sources.length == 0) {
+    throw new SemantifoldDiagnostic({code: "INVALID_TARGET_CHECK_PLAN", language: "javascript",
+      message: "JavaScript developer checks require at least one staged '.js' artifact."})
+  }
+
+  return checkPlan(context, "javascript", artifacts, sources.map((source, index) => checkStage({
+    argv: ["--check", source],
+    cwd: context.sourcePath,
+    inputs: [source, ...(index == 0 ? manifests : [])],
+    output: null,
+    pathArguments: [pathArgument(1, "source")],
+    stage: "validate",
+    tool
+  })))
+}

package/src/backends/kotlin-check.js

@@ -0,0 +1,41 @@
+// @ts-check
+
+import path from "node:path"
+import {
+  checkArtifacts,
+  checkOutput,
+  checkPlan,
+  checkStage,
+  checkTool,
+  environmentPath,
+  pathArgument
+} from "./check-plan.js"
+
+/**
+ * Constructs Kotlin/JVM's non-executing compiler plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable Kotlin plan.
+ */
+export function createKotlinCheckPlan(context) {
+  const tool = checkTool(context, "kotlinc", "kotlin")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".kt"), "kotlin", "only staged '.kt' artifacts")
+  const classes = path.join(context.buildPath, "classes")
+  const home = path.join(context.buildPath, "home")
+  const cache = path.join(context.buildPath, "cache")
+  const temporary = path.join(context.buildPath, "tmp")
+
+  return checkPlan(context, "kotlin", artifacts, [checkStage({
+    argv: ["-language-version", "2.4", "-api-version", "2.4", "-jvm-target", "25", "-Werror", ...artifacts, "-d", classes],
+    cwd: context.sourcePath,
+    environment: {HOME: home, TMPDIR: temporary, XDG_CACHE_HOME: cache},
+    environmentPaths: [environmentPath("HOME", "build"), environmentPath("TMPDIR", "build"), environmentPath("XDG_CACHE_HOME", "build")],
+    inputs: artifacts,
+    output: checkOutput(context.buildPath, "application/java-vm", "compiler-output"),
+    pathArguments: [
+      ...artifacts.map((_, index) => pathArgument(7 + index, "source")),
+      pathArgument(8 + artifacts.length, "build")
+    ],
+    stage: "compile",
+    tool
+  })])
+}

package/src/backends/php-check.js

@@ -0,0 +1,23 @@
+// @ts-check
+
+import {checkArtifacts, checkPlan, checkStage, checkTool, pathArgument} from "./check-plan.js"
+
+/**
+ * Constructs PHP's non-executing syntax-check plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable PHP plan.
+ */
+export function createPhpCheckPlan(context) {
+  const tool = checkTool(context, "php82", "php")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".php"), "php", "only staged '.php' artifacts")
+
+  return checkPlan(context, "php", artifacts, artifacts.map(artifact => checkStage({
+    argv: ["-n", "-l", artifact],
+    cwd: context.sourcePath,
+    inputs: [artifact],
+    output: null,
+    pathArguments: [pathArgument(2, "source")],
+    stage: "validate",
+    tool
+  })))
+}

package/src/backends/program.js

@@ -25,6 +25,23 @@ const programTargets = new Set(["php", "ruby", "javascript", "typescript", "java
 /** @type {Readonly<Set<import("../semantic/types.js").BackendLanguage>>} */
 const programApplicationTargets = new Set(["android", "ios", "flutter"])
 
+/**
+ * Reports whether program generation implements one registered target/role combination.
+ * @param {string} language - Registered target identity.
+ * @param {string} role - Explicit project target role.
+ * @returns {boolean} Whether complete semantic programs support the combination.
+ */
+export function supportsProgramArtifactRole(language, role) {
+  if (role == "text") {
+    return programTargets.has(/** @type {import("../semantic/types.js").SemanticLanguage} */ (language))
+  }
+  if (role == "application") {
+    return programApplicationTargets.has(/** @type {import("../semantic/types.js").BackendLanguage} */ (language))
+  }
+
+  return false
+}
+
 /**
  * Validates and prepares a complete semantic program for a non-text backend without allocating a writer.
  * @param {object} input - Backend preflight request.

package/src/backends/python-check.js

@@ -0,0 +1,30 @@
+// @ts-check
+
+import path from "node:path"
+import {checkArtifacts, checkOutput, checkPlan, checkStage, checkTool, pathArgument} from "./check-plan.js"
+
+/**
+ * Constructs Python's isolated bytecode compiler plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable Python plan.
+ */
+export function createPythonCheckPlan(context) {
+  const tool = checkTool(context, "python", "python")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".py"), "python", "only staged '.py' artifacts")
+  const compiler = "import py_compile,sys;[py_compile.compile(sys.argv[index],cfile=sys.argv[index+1],dfile=sys.argv[index+2],doraise=True,invalidation_mode=py_compile.PycInvalidationMode.CHECKED_HASH) for index in range(1,len(sys.argv),3)]"
+  const arguments_ = artifacts.flatMap(artifactPath => [
+    artifactPath,
+    path.join(context.buildPath, `${path.basename(artifactPath, ".py")}.pyc`),
+    path.basename(artifactPath)
+  ])
+
+  return checkPlan(context, "python", artifacts, [checkStage({
+    argv: ["-I", "-B", "-c", compiler, ...arguments_],
+    cwd: context.sourcePath,
+    inputs: artifacts,
+    output: checkOutput(context.buildPath, "application/x-python-bytecode", "compiler-output"),
+    pathArguments: artifacts.flatMap((_, index) => [pathArgument(4 + index * 3, "source"), pathArgument(5 + index * 3, "build")]),
+    stage: "compile",
+    tool
+  })])
+}

package/src/backends/ruby-check.js

@@ -0,0 +1,23 @@
+// @ts-check
+
+import {checkArtifacts, checkPlan, checkStage, checkTool, pathArgument} from "./check-plan.js"
+
+/**
+ * Constructs Ruby's non-executing syntax-check plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable Ruby plan.
+ */
+export function createRubyCheckPlan(context) {
+  const tool = checkTool(context, "ruby", "ruby")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".rb"), "ruby", "only staged '.rb' artifacts")
+
+  return checkPlan(context, "ruby", artifacts, artifacts.map(artifact => checkStage({
+    argv: ["--disable=gems", "-c", artifact],
+    cwd: context.sourcePath,
+    inputs: [artifact],
+    output: null,
+    pathArguments: [pathArgument(2, "source")],
+    stage: "validate",
+    tool
+  })))
+}

package/src/backends/rust-check.js

@@ -0,0 +1,78 @@
+// @ts-check
+
+import path from "node:path"
+import {SemantifoldDiagnostic} from "../diagnostic.js"
+import {
+  checkArtifacts,
+  checkPlan,
+  checkStage,
+  checkTool,
+  environmentPath,
+  environmentTool,
+  pathArgument
+} from "./check-plan.js"
+import {rustLockfile, rustManifest} from "./rust-runtime.js"
+
+/**
+ * Constructs Rust's locked offline Cargo build/check plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable Cargo plan.
+ */
+export function createRustCheckPlan(context) {
+  const rustc = checkTool(context, "rustc", "rust")
+  const cargo = checkTool(context, "cargo", "rust")
+  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".rs") ||
+    artifact.path == "Cargo.toml" || artifact.path == "Cargo.lock",
+  "rust", "only staged Rust source and canonical Cargo manifest/lock artifacts")
+  const manifest = context.artifacts.artifacts.filter(artifact => artifact.path == "Cargo.toml")
+  const lock = context.artifacts.artifacts.filter(artifact => artifact.path == "Cargo.lock")
+  const sources = artifacts.filter(artifact => artifact.endsWith(".rs"))
+
+  if (manifest.length != 1 || manifest[0].contentKind != "text" || manifest[0].role != "manifest" ||
+    manifest[0].content != rustManifest || lock.length != 1 || lock[0].contentKind != "text" ||
+    lock[0].content != rustLockfile || artifacts.length != 3 || sources.length != 1 ||
+    sources[0] != path.join(context.sourcePath, "src/main.rs")) {
+    throw new SemantifoldDiagnostic({
+      code: "INVALID_TARGET_CHECK_PLAN",
+      language: "rust",
+      message: "Rust developer checks require the exact dependency-free Cargo project/lock and staged '.rs' source."
+    })
+  }
+  const cargoHome = path.join(context.buildPath, "cargo-home")
+  const home = path.join(context.buildPath, "home")
+  const temporary = path.join(context.buildPath, "tmp")
+  const target = path.join(context.buildPath, "cargo-target")
+  const environment = {
+    CARGO_HOME: cargoHome,
+    CARGO_INCREMENTAL: "0",
+    CARGO_NET_OFFLINE: "true",
+    CARGO_TERM_COLOR: "never",
+    HOME: home,
+    PATH: [path.dirname(rustc.executable), path.dirname(cargo.executable), "/usr/local/bin", "/usr/bin", "/bin"].filter((value, index, values) =>
+      values.indexOf(value) == index).join(path.delimiter),
+    RUSTC: rustc.executable,
+    TMPDIR: temporary
+  }
+  const environmentPaths = [environmentPath("CARGO_HOME", "build"), environmentPath("HOME", "build"),
+    environmentTool("RUSTC", rustc), environmentPath("TMPDIR", "build")]
+  /**
+   * Constructs one Cargo stage over the complete generated project.
+   * @param {import("../semantic/types.js").AcceptanceStage} name - Registry stage identity.
+   * @param {string} command - Exact Cargo subcommand.
+   * @returns {import("../semantic/types.js").TargetCheckStageRequest} Immutable stage.
+   */
+  const stage = (name, command) => checkStage({
+    argv: [command, "--offline", "--locked", "--target-dir", target],
+    cwd: context.sourcePath,
+    environment,
+    environmentPaths,
+    inputs: artifacts,
+    output: null,
+    pathArguments: [pathArgument(4, "build")],
+    stage: name,
+    tool: cargo,
+    transientPaths: [target]
+  })
+
+  return checkPlan(context, "rust", artifacts, [stage("compile", "build"), stage("validate", "check")])
+}