semantifold 0.9.0 → 0.11.0

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",

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/kotlin.js

@@ -15,7 +15,7 @@ export const kotlinArtifactMetadata = Object.freeze({
     toolchain: "kotlinc",
     version: "2.4.20"
   }),
-  run: Object.freeze({arguments: Object.freeze(["-jar", "Program.jar"]), toolchain: "java25", version: "25.0.4+7"})
+  run: Object.freeze({arguments: Object.freeze(["-jar", "Program.jar"]), toolchain: "java25", version: "25.0.4.1"})
 })
 
 /**

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.