semantifold 0.9.0 → 0.11.0

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

@@ -37,6 +37,7 @@ const task012Languages = new Set(["php", "ruby", "javascript", "typescript", "ja
 const task014Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task032Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task033Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
+const task048ConditionalLanguages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const javaReferenceMethodHooks = new Set(["clone", "equals", "finalize", "getClass", "hashCode", "notify", "notifyAll", "toString", "wait"])
 const javascriptReferenceMethodHooks = new Set([
   "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "__proto__", "constructor",
@@ -1129,6 +1130,11 @@ function expressionContainsKind(expression, kind) {
   if (expression.kind == "BinaryExpression") {
     return expressionContainsKind(expression.left, kind) || expressionContainsKind(expression.right, kind)
   }
+  if (expression.kind == "ConditionalExpression") {
+    return expressionContainsKind(expression.condition, kind) ||
+      expressionContainsKind(expression.consequent, kind) ||
+      expressionContainsKind(expression.alternate, kind)
+  }
   if (expression.kind == "CallExpression") return expression.arguments.some((argument) => expressionContainsKind(argument, kind))
   if (expression.kind == "MethodCallExpression") {
     return expressionContainsKind(expression.receiver, kind) ||
@@ -1936,6 +1942,19 @@ function validateExpression(expression, language, ownerLocation, allowJavaNegate
     return
   }
 
+  if (candidate.kind == "ConditionalExpression") {
+    const fields = Object.keys(candidate).filter((key) => key != "sourceProvenance").sort().join(",")
+
+    if (fields != "alternate,condition,consequent,kind,location,type") {
+      unsupportedCapability(language, "malformed ConditionalExpression", location)
+    }
+    if (!task048ConditionalLanguages.has(language)) unsupportedCapability(language, "Task 048 conditional expression", location)
+    validateExpression(candidate.condition, language, location, false, expressionPath, externalDeclarationIds)
+    validateExpression(candidate.consequent, language, location, false, expressionPath, externalDeclarationIds)
+    validateExpression(candidate.alternate, language, location, false, expressionPath, externalDeclarationIds)
+    return
+  }
+
   unsupportedCapability(language, String(Reflect.get(expression, "kind")), location)
 }
 
@@ -2364,6 +2383,17 @@ export function emitExpression(writer, expression, path, language, emitIdentifie
     return
   }
 
+  if (expression.kind == "ConditionalExpression") {
+    writer.mapped("(", {mappingKind: "anchor", node: expression, path})
+    emitExpression(writer, expression.condition, `${path}/condition`, language, emitIdentifier)
+    writer.mapped(" ? ", {mappingKind: "exact", node: expression, path, role: "operator"})
+    emitExpression(writer, expression.consequent, `${path}/consequent`, language, emitIdentifier)
+    writer.mapped(" : ", {mappingKind: "exact", node: expression, path, role: "colon"})
+    emitExpression(writer, expression.alternate, `${path}/alternate`, language, emitIdentifier)
+    writer.mapped(")", {mappingKind: "anchor", node: expression, path})
+    return
+  }
+
   if (expression.kind == "UnaryExpression") {
     if (language == "dart" && expression.operation == "IntegerNegate") {
       emitDartIntegerHelper(writer, expression, path, "_semantifoldIntegerNegate", [

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

@@ -329,6 +329,29 @@ function convertExpression(node, filename, source, context, expectedType) {
     return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (semantic))
   }
 
+  if (node.name == "TernaryExpression") {
+    const children = directChildren(node)
+    const question = children.find((child) => child.name == "?" || (child.name == "LogicOp" && nodeText(child, source) == "?"))
+    const colon = children.find((child) => child.name == ":" || (child.name == "LogicOp" && nodeText(child, source) == ":"))
+    const named = children.filter((child) => child !== question && child !== colon)
+
+    if (!question || !colon || named.length != 3) return unsupportedSyntax("java", "ternary expression", location)
+
+    return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (withParserRanges({
+      alternate: convertExpression(named[2], filename, source, context),
+      condition: convertExpression(named[0], filename, source, context),
+      consequent: convertExpression(named[1], filename, source, context),
+      kind: /** @type {const} */ ("ConditionalExpression"),
+      location
+    }, {
+      alternate: nodeLocation(named[2], filename, source),
+      colon: nodeLocation(colon, filename, source),
+      condition: nodeLocation(named[0], filename, source),
+      consequent: nodeLocation(named[1], filename, source),
+      operator: nodeLocation(question, filename, source)
+    })))
+  }
+
   if (node.name == "MethodInvocation") {
     if (isEqualsInvocation(node, source) && !isZeroArgumentRecordMemberInvocation(node, filename, source, context)) {
       const methodName = requiredChild(node, "MethodName", filename, source)
@@ -626,6 +649,7 @@ function isSupportedExpressionNode(node) {
     "StringLiteral",
     "UnaryExpression",
     "BinaryExpression",
+    "TernaryExpression",
     "MethodInvocation",
     "ObjectCreationExpression",
     "FieldAccess",

package/src/frontends/javascript-typescript.js

@@ -7,7 +7,7 @@ import {blockReferencesProtectedEntry} from "../semantic/effects.js"
 import {locationFromOffsets, moduleLocation} from "../semantic/location.js"
 import {withAdaptedOperation} from "../semantic/operators.js"
 import {withParserRanges} from "../semantic/provenance.js"
-import {hasOnlyUnicodeScalars} from "../semantic/scalars.js"
+import {hasOnlyUnicodeScalars, scalarType} from "../semantic/scalars.js"
 import {isTask034ResourceProbe} from "../semantic/capabilities.js"
 import {hasExactEffectSupport} from "../backends/effects.js"
 import {requireSourceReturnType, requireSourceScalarType} from "./scalars.js"
@@ -431,7 +431,38 @@ function convertExpression(node, language, filename, source, context = {bindings
   }
 
   if (node.type == "TemplateLiteral") {
-    if (node.expressions.length > 0) return unsupportedSyntax(language, "interpolated string", location)
+    if (node.expressions.length > 0) {
+      /** @type {import("../semantic/types.js").Expression[]} */
+      const ordered = []
+
+      node.quasis.forEach((quasi, index) => {
+        if (typeof quasi.value.cooked != "string" || !hasOnlyUnicodeScalars(quasi.value.cooked)) {
+          return unsupportedSyntax(language, "invalid Unicode string literal", nodeLocation(quasi, filename, source))
+        }
+        const quasiLocation = nodeLocation(quasi, filename, source)
+
+        if (quasi.value.cooked.length > 0) ordered.push(withParserRanges({kind: /** @type {const} */ ("StringLiteral"), location: quasiLocation, value: quasi.value.cooked}, {literal: quasiLocation}))
+        if (index < node.expressions.length) {
+          ordered.push(convertExpression(/** @type {import("@babel/types").Expression} */ (node.expressions[index]), language, filename, source, context, scalarType("string")))
+        }
+      })
+      if (ordered.length == 0) return unsupportedSyntax(language, "interpolated string", location)
+
+      let lowered = ordered[0]
+
+      for (const part of ordered.slice(1)) {
+        const semantic = withAdaptedOperation({
+          kind: /** @type {const} */ ("BinaryExpression"),
+          left: lowered,
+          location,
+          right: part
+        }, /** @type {import("../semantic/operators.js").AdaptedOperation} */ ("StringConcat"))
+
+        lowered = /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (semantic))
+      }
+
+      return lowered
+    }
 
     const quasi = node.quasis[0]
 
@@ -442,6 +473,22 @@ function convertExpression(node, language, filename, source, context = {bindings
     return withParserRanges({kind: /** @type {const} */ ("StringLiteral"), location, value: quasi.value.cooked}, {literal: location})
   }
 
+  if (node.type == "ConditionalExpression") {
+    return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (withParserRanges({
+      alternate: convertExpression(node.alternate, language, filename, source, context),
+      condition: convertExpression(node.test, language, filename, source, context),
+      consequent: convertExpression(node.consequent, language, filename, source, context),
+      kind: /** @type {const} */ ("ConditionalExpression"),
+      location
+    }, {
+      alternate: nodeLocation(node.alternate, filename, source),
+      colon: tokenLocation(node, ":", node.consequent.end ?? node.test.end ?? node.start ?? 0, node.alternate.start ?? node.end ?? source.length, filename, source),
+      condition: nodeLocation(node.test, filename, source),
+      consequent: nodeLocation(node.consequent, filename, source),
+      operator: tokenLocation(node, "?", node.test.end ?? node.start ?? 0, node.consequent.start ?? node.end ?? source.length, filename, source)
+    })))
+  }
+
   if (node.type == "UnaryExpression" && ["!", "-"].includes(node.operator)) {
     const operand = convertExpression(node.argument, language, filename, source, context)
     const semantic = withAdaptedOperation(withParserRanges({

package/src/frontends/php.js

@@ -222,9 +222,37 @@ function convertExpression(node, filename, source, context, expectedType, preser
 
   if (node.kind == "encapsed") {
     const literal = /** @type {import("php-parser").Encapsed} */ (node)
-    const detail = literal.type == "string" ? "interpolated string" : `${literal.type} string`
 
-    return unsupportedSyntax("php", detail, location)
+    if (literal.type != "string") return unsupportedSyntax("php", `${literal.type} string`, location)
+    if (!Array.isArray(literal.value)) return unsupportedSyntax("php", "interpolated string", location)
+
+    const parts = literal.value.map((part) => {
+      if (part.kind != "encapsedpart") return unsupportedSyntax("php", `interpolated string part ${part.kind}`, nodeLocation(part, filename, source))
+      const encapsedPart = /** @type {import("php-parser").EncapsedPart} */ (part)
+
+      if (!encapsedPart.expression) return unsupportedSyntax("php", "interpolated string part without expression", nodeLocation(encapsedPart, filename, source))
+
+      return convertExpression(encapsedPart.expression, filename, source, context, scalarType("string"))
+    })
+
+    if (parts.length == 0) {
+      return withParserRanges({kind: /** @type {const} */ ("StringLiteral"), location, value: ""}, {literal: location})
+    }
+
+    let lowered = parts[0]
+
+    for (const part of parts.slice(1)) {
+      const semantic = withAdaptedOperation({
+        kind: /** @type {const} */ ("BinaryExpression"),
+        left: lowered,
+        location,
+        right: part
+      }, /** @type {import("../semantic/operators.js").AdaptedOperation} */ ("StringConcat"))
+
+      lowered = /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (semantic))
+    }
+
+    return withParserRanges(lowered, {literal: location})
   }
 
   if (node.kind == "nowdoc") return unsupportedSyntax("php", "nowdoc string", location)
@@ -414,6 +442,37 @@ function convertExpression(node, filename, source, context, expectedType, preser
     return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (semantic))
   }
 
+  if (node.kind == "retif") {
+    const ternary = /** @type {import("php-parser").RetIf} */ (node)
+
+    if (!ternary.test || !ternary.trueExpr || !ternary.falseExpr) return unsupportedSyntax("php", "short ternary", location)
+    if (ternary.test.kind == "variable") {
+      const tested = /** @type {import("php-parser").Variable} */ (ternary.test)
+
+      if (typeof tested.name == "string" && context.bindings.get(tested.name)?.kind == "OptionalType") {
+        return unsupportedSyntax("php", "optional truthiness condition", nodeLocation(tested, filename, source))
+      }
+    }
+
+    return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (withParserRanges({
+      alternate: convertExpression(ternary.falseExpr, filename, source, context),
+      condition: convertExpression(ternary.test, filename, source, context),
+      consequent: convertExpression(ternary.trueExpr, filename, source, context),
+      kind: /** @type {const} */ ("ConditionalExpression"),
+      location
+    }, {
+      alternate: tokenLocation(":", ternary.trueExpr.loc?.end.offset ?? 0, ternary.falseExpr.loc?.start.offset ?? source.length, filename, source),
+      colon: tokenLocation(":", ternary.trueExpr.loc?.end.offset ?? 0, ternary.falseExpr.loc?.start.offset ?? source.length, filename, source),
+      condition: ternary.test.loc ? nodeLocation(ternary.test, filename, source) : location,
+      consequent: ternary.trueExpr.loc ? nodeLocation(ternary.trueExpr, filename, source) : location,
+      operator: tokenLocation("?", ternary.test.loc?.end.offset ?? 0, ternary.trueExpr.loc?.start.offset ?? source.length, filename, source)
+    })))
+  }
+
+  if (node.kind == "nullsafepropertylookup" || node.kind == "nullsafemethodcall") {
+    return unsupportedSyntax("php", "safe navigation", location)
+  }
+
   if (node.kind == "bin") {
     const binary = /** @type {import("php-parser").Bin} */ (node)
     if (binary.type == "!==" && binary.left.kind == "variable" && binary.right.kind == "nullkeyword") {

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 */