semantifold 0.9.0 → 0.10.0

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")])
+}

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
+  })])
+}