semantifold 0.9.0 → 0.10.0

package/build/src/backends/check-plan.js

@@ -0,0 +1,135 @@
+// @ts-check
+import path from "node:path";
+import { SemantifoldDiagnostic } from "../diagnostic.js";
+import { deterministicEnvironment } from "../toolchains.js";
+/**
+ * Resolves one target-declared discovered tool from immutable plan context.
+ * @param {Readonly<{tools: readonly import("../semantic/types.js").DiscoveredToolchain[]}>} context - Plan context.
+ * @param {string} id - Declared toolchain identity.
+ * @param {string} target - Target diagnostic identity.
+ * @returns {import("../semantic/types.js").DiscoveredToolchain} Exact tool.
+ */
+export function checkTool(context, id, target) {
+    const tool = context.tools.find(candidate => candidate.id == id);
+    if (!tool) {
+        throw new SemantifoldDiagnostic({
+            code: "INVALID_TARGET_CHECK_PLAN",
+            language: target,
+            message: `Target '${target}' developer checks require the declared '${id}' toolchain.`
+        });
+    }
+    return tool;
+}
+/**
+ * Resolves all staged artifacts matching one target-owned predicate.
+ * @param {Readonly<{artifacts: import("../semantic/types.js").GeneratedArtifactSet, sourcePath: string}>} context - Plan context.
+ * @param {(artifact: import("../semantic/types.js").GeneratedSetArtifact) => boolean} accepts - Target-owned artifact predicate.
+ * @param {string} target - Target diagnostic identity.
+ * @param {string} description - Required artifact description.
+ * @returns {readonly string[]} Ordered absolute artifact paths.
+ */
+export function checkArtifacts(context, accepts, target, description) {
+    const accepted = context.artifacts.artifacts.filter(accepts);
+    if (accepted.length == 0 || accepted.length != context.artifacts.artifacts.length) {
+        throw new SemantifoldDiagnostic({
+            code: "INVALID_TARGET_CHECK_PLAN",
+            language: target,
+            message: `Target '${target}' developer checks require ${description}.`
+        });
+    }
+    return Object.freeze(accepted.map(artifact => path.join(context.sourcePath, artifact.path))
+        .sort((left, right) => left.localeCompare(right, "en")));
+}
+/**
+ * Freezes one closed target-check stage request.
+ * @param {object} input - Complete stage data.
+ * @param {readonly string[]} input.argv - Exact argv.
+ * @param {string} input.cwd - Candidate-owned working directory.
+ * @param {Readonly<Record<string, string | undefined>>} [input.environment] - Target-owned environment additions.
+ * @param {readonly import("../semantic/types.js").TargetCheckEnvironmentPath[]} [input.environmentPaths] - Owned environment paths.
+ * @param {string | null} [input.inputHash] - Restore-input hash when applicable.
+ * @param {readonly string[]} input.inputs - Exact staged inputs read by the tool.
+ * @param {import("../semantic/types.js").TargetCheckOutputOwnership | null} input.output - Produced build ownership.
+ * @param {readonly import("../semantic/types.js").TargetCheckPathArgument[]} input.pathArguments - Owned argv paths.
+ * @param {import("../semantic/types.js").AcceptanceStage} input.stage - Stage identity.
+ * @param {import("../semantic/types.js").DiscoveredToolchain} input.tool - Exact tool.
+ * @param {readonly string[]} [input.transientPaths] - Owned cache/intermediate directories.
+ * @returns {import("../semantic/types.js").TargetCheckStageRequest} Immutable stage.
+ */
+export function checkStage(input) {
+    return Object.freeze({
+        argv: Object.freeze([...input.argv]),
+        cwd: input.cwd,
+        environment: deterministicEnvironment(input.environment ?? {}),
+        environmentPaths: Object.freeze([...(input.environmentPaths ?? [])]),
+        executable: input.tool.executable,
+        inputHash: input.inputHash ?? null,
+        inputs: Object.freeze([...input.inputs]),
+        output: input.output,
+        pathArguments: Object.freeze([...input.pathArguments]),
+        stage: input.stage,
+        tool: input.tool,
+        transientPaths: Object.freeze([...(input.transientPaths ?? [])])
+    });
+}
+/**
+ * Freezes one closed target-owned plan.
+ * @param {Readonly<{buildPath: string, projectId: string, sourcePath: string, targetId: string}>} context - Plan context.
+ * @param {string} target - Target identity.
+ * @param {readonly string[]} artifactPaths - Complete staged artifact vector.
+ * @param {readonly import("../semantic/types.js").TargetCheckStageRequest[]} stages - Ordered stages.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable plan.
+ */
+export function checkPlan(context, target, artifactPaths, stages) {
+    return Object.freeze({
+        artifactPaths,
+        buildPath: context.buildPath,
+        mode: /** @type {const} */ ("developer-check"),
+        projectId: context.projectId,
+        schema: /** @type {const} */ ("SemantifoldTargetCheckPlan"),
+        sourcePath: context.sourcePath,
+        stages: Object.freeze([...stages]),
+        target,
+        targetId: context.targetId,
+        version: /** @type {const} */ (1)
+    });
+}
+/**
+ * Freezes one owned argv-path declaration.
+ * @param {number} index - Exact argv index.
+ * @param {"source" | "build"} ownership - Owning candidate subtree.
+ * @param {string} [prefix] - Optional non-path argument prefix.
+ * @returns {import("../semantic/types.js").TargetCheckPathArgument} Immutable declaration.
+ */
+export function pathArgument(index, ownership, prefix) {
+    return Object.freeze({ index, ownership, ...(prefix === undefined ? {} : { prefix }) });
+}
+/**
+ * Freezes one owned environment-directory declaration.
+ * @param {string} name - Exact environment variable.
+ * @param {"source" | "build"} ownership - Owning candidate subtree.
+ * @returns {import("../semantic/types.js").TargetCheckEnvironmentPath} Immutable declaration.
+ */
+export function environmentPath(name, ownership) {
+    return Object.freeze({ name, ownership });
+}
+/**
+ * Freezes one exact tool-executable environment binding.
+ * @param {string} name - Exact environment variable.
+ * @param {import("../semantic/types.js").DiscoveredToolchain} tool - Exact discovered tool.
+ * @returns {import("../semantic/types.js").TargetCheckEnvironmentPath} Immutable declaration.
+ */
+export function environmentTool(name, tool) {
+    return Object.freeze({ name, ownership: /** @type {const} */ ("tool"), tool });
+}
+/**
+ * Freezes build-output ownership metadata.
+ * @param {string} buildPath - Exact candidate build root.
+ * @param {string} mediaType - Output media type.
+ * @param {string} role - Language-neutral output role.
+ * @returns {import("../semantic/types.js").TargetCheckOutputOwnership} Immutable ownership.
+ */
+export function checkOutput(buildPath, mediaType, role) {
+    return Object.freeze({ mediaType, ownership: /** @type {const} */ ("build"), path: buildPath, role });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"check-plan.js","sourceRoot":"","sources":["../../../src/backends/check-plan.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"node:path\"\nimport {SemantifoldDiagnostic} from \"../diagnostic.js\"\nimport {deterministicEnvironment} from \"../toolchains.js\"\n\n/**\n * Resolves one target-declared discovered tool from immutable plan context.\n * @param {Readonly<{tools: readonly import(\"../semantic/types.js\").DiscoveredToolchain[]}>} context - Plan context.\n * @param {string} id - Declared toolchain identity.\n * @param {string} target - Target diagnostic identity.\n * @returns {import(\"../semantic/types.js\").DiscoveredToolchain} Exact tool.\n */\nexport function checkTool(context, id, target) {\n  const tool = context.tools.find(candidate => candidate.id == id)\n\n  if (!tool) {\n    throw new SemantifoldDiagnostic({\n      code: \"INVALID_TARGET_CHECK_PLAN\",\n      language: target,\n      message: `Target '${target}' developer checks require the declared '${id}' toolchain.`\n    })\n  }\n\n  return tool\n}\n\n/**\n * Resolves all staged artifacts matching one target-owned predicate.\n * @param {Readonly<{artifacts: import(\"../semantic/types.js\").GeneratedArtifactSet, sourcePath: string}>} context - Plan context.\n * @param {(artifact: import(\"../semantic/types.js\").GeneratedSetArtifact) => boolean} accepts - Target-owned artifact predicate.\n * @param {string} target - Target diagnostic identity.\n * @param {string} description - Required artifact description.\n * @returns {readonly string[]} Ordered absolute artifact paths.\n */\nexport function checkArtifacts(context, accepts, target, description) {\n  const accepted = context.artifacts.artifacts.filter(accepts)\n\n  if (accepted.length == 0 || accepted.length != context.artifacts.artifacts.length) {\n    throw new SemantifoldDiagnostic({\n      code: \"INVALID_TARGET_CHECK_PLAN\",\n      language: target,\n      message: `Target '${target}' developer checks require ${description}.`\n    })\n  }\n\n  return Object.freeze(accepted.map(artifact => path.join(context.sourcePath, artifact.path))\n    .sort((left, right) => left.localeCompare(right, \"en\")))\n}\n\n/**\n * Freezes one closed target-check stage request.\n * @param {object} input - Complete stage data.\n * @param {readonly string[]} input.argv - Exact argv.\n * @param {string} input.cwd - Candidate-owned working directory.\n * @param {Readonly<Record<string, string | undefined>>} [input.environment] - Target-owned environment additions.\n * @param {readonly import(\"../semantic/types.js\").TargetCheckEnvironmentPath[]} [input.environmentPaths] - Owned environment paths.\n * @param {string | null} [input.inputHash] - Restore-input hash when applicable.\n * @param {readonly string[]} input.inputs - Exact staged inputs read by the tool.\n * @param {import(\"../semantic/types.js\").TargetCheckOutputOwnership | null} input.output - Produced build ownership.\n * @param {readonly import(\"../semantic/types.js\").TargetCheckPathArgument[]} input.pathArguments - Owned argv paths.\n * @param {import(\"../semantic/types.js\").AcceptanceStage} input.stage - Stage identity.\n * @param {import(\"../semantic/types.js\").DiscoveredToolchain} input.tool - Exact tool.\n * @param {readonly string[]} [input.transientPaths] - Owned cache/intermediate directories.\n * @returns {import(\"../semantic/types.js\").TargetCheckStageRequest} Immutable stage.\n */\nexport function checkStage(input) {\n  return Object.freeze({\n    argv: Object.freeze([...input.argv]),\n    cwd: input.cwd,\n    environment: deterministicEnvironment(input.environment ?? {}),\n    environmentPaths: Object.freeze([...(input.environmentPaths ?? [])]),\n    executable: input.tool.executable,\n    inputHash: input.inputHash ?? null,\n    inputs: Object.freeze([...input.inputs]),\n    output: input.output,\n    pathArguments: Object.freeze([...input.pathArguments]),\n    stage: input.stage,\n    tool: input.tool,\n    transientPaths: Object.freeze([...(input.transientPaths ?? [])])\n  })\n}\n\n/**\n * Freezes one closed target-owned plan.\n * @param {Readonly<{buildPath: string, projectId: string, sourcePath: string, targetId: string}>} context - Plan context.\n * @param {string} target - Target identity.\n * @param {readonly string[]} artifactPaths - Complete staged artifact vector.\n * @param {readonly import(\"../semantic/types.js\").TargetCheckStageRequest[]} stages - Ordered stages.\n * @returns {import(\"../semantic/types.js\").TargetCheckPlan} Immutable plan.\n */\nexport function checkPlan(context, target, artifactPaths, stages) {\n  return Object.freeze({\n    artifactPaths,\n    buildPath: context.buildPath,\n    mode: /** @type {const} */ (\"developer-check\"),\n    projectId: context.projectId,\n    schema: /** @type {const} */ (\"SemantifoldTargetCheckPlan\"),\n    sourcePath: context.sourcePath,\n    stages: Object.freeze([...stages]),\n    target,\n    targetId: context.targetId,\n    version: /** @type {const} */ (1)\n  })\n}\n\n/**\n * Freezes one owned argv-path declaration.\n * @param {number} index - Exact argv index.\n * @param {\"source\" | \"build\"} ownership - Owning candidate subtree.\n * @param {string} [prefix] - Optional non-path argument prefix.\n * @returns {import(\"../semantic/types.js\").TargetCheckPathArgument} Immutable declaration.\n */\nexport function pathArgument(index, ownership, prefix) {\n  return Object.freeze({index, ownership, ...(prefix === undefined ? {} : {prefix})})\n}\n\n/**\n * Freezes one owned environment-directory declaration.\n * @param {string} name - Exact environment variable.\n * @param {\"source\" | \"build\"} ownership - Owning candidate subtree.\n * @returns {import(\"../semantic/types.js\").TargetCheckEnvironmentPath} Immutable declaration.\n */\nexport function environmentPath(name, ownership) {\n  return Object.freeze({name, ownership})\n}\n\n/**\n * Freezes one exact tool-executable environment binding.\n * @param {string} name - Exact environment variable.\n * @param {import(\"../semantic/types.js\").DiscoveredToolchain} tool - Exact discovered tool.\n * @returns {import(\"../semantic/types.js\").TargetCheckEnvironmentPath} Immutable declaration.\n */\nexport function environmentTool(name, tool) {\n  return Object.freeze({name, ownership: /** @type {const} */ (\"tool\"), tool})\n}\n\n/**\n * Freezes build-output ownership metadata.\n * @param {string} buildPath - Exact candidate build root.\n * @param {string} mediaType - Output media type.\n * @param {string} role - Language-neutral output role.\n * @returns {import(\"../semantic/types.js\").TargetCheckOutputOwnership} Immutable ownership.\n */\nexport function checkOutput(buildPath, mediaType, role) {\n  return Object.freeze({mediaType, ownership: /** @type {const} */ (\"build\"), path: buildPath, role})\n}\n"]}

package/build/src/backends/cpp-check.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Constructs C++'s strict Clang C++20/libstdc++ compile/link plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable C++ plan.
+ */
+export declare function createCppCheckPlan(context: import("../language-registry.js").TargetCheckPlanContext): import("../semantic/types.js").TargetCheckPlan;
+//# sourceMappingURL=cpp-check.d.ts.map

package/build/src/backends/cpp-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpp-check.d.ts","sourceRoot":"","sources":["../../../src/backends/cpp-check.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAH/B,OAAO,yBAAyB,EAAE,sBAGH,GAF7B,OAAO,sBAAsB,EAAE,eAAe,CAiD1D"}

package/build/src/backends/cpp-check.js

@@ -0,0 +1,59 @@
+// @ts-check
+import path from "node:path";
+import { SemantifoldDiagnostic } from "../diagnostic.js";
+import { checkArtifacts, checkOutput, checkPlan, checkStage, checkTool, environmentPath, pathArgument } from "./check-plan.js";
+const compilerFlags = Object.freeze([
+    "--no-default-config", "--driver-mode=g++", "-std=c++20", "-stdlib=libstdc++", "-Wall", "-Wextra", "-Werror",
+    "-pedantic-errors", "-Wconversion", "-Wsign-conversion", "-Wshadow", "-Wformat=2", "-fno-exceptions", "-fno-rtti",
+    "-ftrapv", "-finput-charset=UTF-8", "-fexec-charset=UTF-8", "-fno-color-diagnostics", "-O0"
+]);
+/**
+ * Constructs C++'s strict Clang C++20/libstdc++ compile/link plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable C++ plan.
+ */
+export function createCppCheckPlan(context) {
+    const tool = checkTool(context, "clangpp", "cpp");
+    const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".cpp"), "cpp", "only staged '.cpp' translation units");
+    if (artifacts.length != 1 || artifacts[0] != path.join(context.sourcePath, "program.cpp")) {
+        throw new SemantifoldDiagnostic({ code: "INVALID_TARGET_CHECK_PLAN", language: "cpp",
+            message: "C++ developer checks require the exact producer-owned 'program.cpp' translation unit." });
+    }
+    const objects = path.join(context.buildPath, "objects");
+    const temporary = path.join(context.buildPath, "tmp");
+    const environment = { TMPDIR: temporary };
+    const environmentPaths = [environmentPath("TMPDIR", "build")];
+    const objectPaths = artifacts.map((_, index) => path.join(objects, `${String(index).padStart(6, "0")}.o`));
+    const stages = artifacts.map((source, index) => {
+        const argv = [...compilerFlags, "-c", source, "-o", objectPaths[index]];
+        return checkStage({
+            argv,
+            cwd: context.sourcePath,
+            environment,
+            environmentPaths,
+            inputs: [source],
+            output: null,
+            pathArguments: [pathArgument(argv.length - 3, "source"), pathArgument(argv.length - 1, "build")],
+            stage: /** @type {const} */ ("compile"),
+            tool,
+            transientPaths: [objects]
+        });
+    });
+    const binary = path.join(context.buildPath, "semantifold-cpp");
+    const linkArgv = ["--no-default-config", "--driver-mode=g++", "-stdlib=libstdc++", "-O0", ...objectPaths, "-o", binary];
+    stages.push(checkStage({
+        argv: linkArgv,
+        cwd: context.sourcePath,
+        environment,
+        environmentPaths,
+        inputs: objectPaths,
+        output: checkOutput(context.buildPath, "application/x-executable", "linker-output"),
+        pathArguments: [...objectPaths.map((_, index) => pathArgument(index + 4, "build")),
+            pathArgument(linkArgv.length - 1, "build")],
+        stage: "link",
+        tool,
+        transientPaths: [objects]
+    }));
+    return checkPlan(context, "cpp", artifacts, stages);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/backends/csharp-check.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 declare function createCSharpCheckPlan(context: import("../language-registry.js").TargetCheckPlanContext): import("../semantic/types.js").TargetCheckPlan;
+//# sourceMappingURL=csharp-check.d.ts.map

package/build/src/backends/csharp-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csharp-check.d.ts","sourceRoot":"","sources":["../../../src/backends/csharp-check.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAHlC,OAAO,yBAAyB,EAAE,sBAGA,GAFhC,OAAO,sBAAsB,EAAE,eAAe,CAuH1D"}

package/build/src/backends/csharp-check.js

@@ -0,0 +1,125 @@
+// @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]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"csharp-check.js","sourceRoot":"","sources":["../../../src/backends/csharp-check.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createHash} from \"node:crypto\"\nimport path from \"node:path\"\nimport {SemantifoldDiagnostic} from \"../diagnostic.js\"\nimport {\n  checkArtifacts,\n  checkOutput,\n  checkPlan,\n  checkStage,\n  checkTool,\n  environmentPath,\n  pathArgument\n} from \"./check-plan.js\"\nimport {csharpProjectManifest} from \"./csharp.js\"\n\n/**\n * Constructs C#'s offline restore and non-executing build plan.\n * @param {import(\"../language-registry.js\").TargetCheckPlanContext} context - Validated candidate context.\n * @returns {import(\"../semantic/types.js\").TargetCheckPlan} Immutable C# plan.\n */\nexport function createCSharpCheckPlan(context) {\n  const tool = checkTool(context, \"dotnet\", \"csharp\")\n  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(\".cs\") ||\n    artifact.path == \"Semantifold.csproj\" || artifact.path == \"packages.lock.json\",\n  \"csharp\", \"only staged C# source and canonical project/lock artifacts\")\n  const projects = context.artifacts.artifacts.filter(artifact => artifact.path == \"Semantifold.csproj\")\n  const sources = artifacts.filter(artifact => artifact.endsWith(\".cs\"))\n\n  if (projects.length != 1 || projects[0].contentKind != \"text\" || projects[0].role != \"manifest\" ||\n    projects[0].content != csharpProjectManifest) {\n    throw new SemantifoldDiagnostic({\n      code: \"INVALID_TARGET_CHECK_PLAN\",\n      language: \"csharp\",\n      message: \"C# developer checks require the exact producer-owned 'Semantifold.csproj' artifact.\"\n    })\n  }\n  if (sources.length == 0) {\n    throw new SemantifoldDiagnostic({\n      code: \"INVALID_TARGET_CHECK_PLAN\",\n      language: \"csharp\",\n      message: \"C# developer checks require at least one staged '.cs' artifact.\"\n    })\n  }\n  const restoreArtifacts = context.artifacts.artifacts\n    .filter(artifact => artifact.path == \"Semantifold.csproj\" || artifact.path == \"packages.lock.json\")\n    .sort((left, right) => left.path.localeCompare(right.path, \"en\"))\n  const restoreInputs = Object.freeze(restoreArtifacts.map(artifact => path.join(context.sourcePath, artifact.path)))\n  const restoreHash = createHash(\"sha256\")\n\n  for (const artifact of restoreArtifacts) {\n    const contentLength = typeof artifact.content == \"string\" ? Buffer.byteLength(artifact.content) : artifact.content.byteLength\n\n    restoreHash.update(`${Buffer.byteLength(artifact.path)}:`).update(artifact.path)\n      .update(`${contentLength}:`).update(artifact.content)\n  }\n  const inputHash = restoreHash.digest(\"hex\")\n  const projectPath = path.join(context.sourcePath, projects[0].path)\n  const packages = path.join(context.buildPath, \"nuget-packages\")\n  const intermediatePath = path.join(context.buildPath, \"obj\")\n  const intermediate = `${intermediatePath}/`\n  const output = path.join(context.buildPath, \"bin\")\n  const compileItems = sources.map(source => path.relative(context.sourcePath, source).split(path.sep).join(\"/\")).join(\"%3B\")\n  const isolatedProjectProperties = [\n    \"--property:ImportDirectoryBuildProps=false\",\n    \"--property:ImportDirectoryBuildTargets=false\"\n  ]\n  const restoreArgv = [\n    \"restore\", projectPath, \"--source\", context.sourcePath, \"--packages\", packages, \"--no-cache\", \"--force\",\n    \"--disable-parallel\",\n    ...(restoreArtifacts.some(artifact => artifact.path == \"packages.lock.json\") ? [\"--locked-mode\"] : []),\n    \"--nologo\", ...isolatedProjectProperties, `--property:BaseIntermediateOutputPath=${intermediate}`,\n    `--property:MSBuildProjectExtensionsPath=${intermediate}`\n  ]\n  const compileArgv = [\n    \"build\", projectPath, \"--configuration\", \"Release\", \"--no-restore\", \"--nologo\", \"--warnaserror\",\n    \"--disable-build-servers\", \"--output\", output, ...isolatedProjectProperties,\n    `--property:SemantifoldCompileItems=${compileItems}`, \"--property:UseSharedCompilation=false\",\n    `--property:BaseIntermediateOutputPath=${intermediate}`,\n    `--property:MSBuildProjectExtensionsPath=${intermediate}`\n  ]\n  const environment = {\n    DOTNET_CLI_HOME: path.join(context.buildPath, \"dotnet-home\"),\n    DOTNET_CLI_TELEMETRY_OPTOUT: \"1\",\n    DOTNET_CLI_USE_MSBUILD_SERVER: \"0\",\n    DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE: \"1\",\n    DOTNET_NOLOGO: \"1\",\n    DOTNET_SKIP_FIRST_TIME_EXPERIENCE: \"1\",\n    DOTNET_SYSTEM_GLOBALIZATION_INVARIANT: \"1\",\n    HOME: path.join(context.buildPath, \"home\"),\n    NUGET_HTTP_CACHE_PATH: path.join(context.buildPath, \"nuget-http-cache\"),\n    NUGET_PACKAGES: packages,\n    NUGET_PLUGINS_CACHE_PATH: path.join(context.buildPath, \"nuget-plugins-cache\"),\n    TMPDIR: path.join(context.buildPath, \"tmp\"),\n    XDG_CACHE_HOME: path.join(context.buildPath, \"cache\")\n  }\n  const environmentPaths = [\n    environmentPath(\"DOTNET_CLI_HOME\", \"build\"), environmentPath(\"HOME\", \"build\"),\n    environmentPath(\"NUGET_HTTP_CACHE_PATH\", \"build\"), environmentPath(\"NUGET_PACKAGES\", \"build\"),\n    environmentPath(\"NUGET_PLUGINS_CACHE_PATH\", \"build\"), environmentPath(\"TMPDIR\", \"build\"),\n    environmentPath(\"XDG_CACHE_HOME\", \"build\")\n  ]\n  const ownedOutput = checkOutput(context.buildPath, \"application/octet-stream\", \"compiler-output\")\n  const restore = checkStage({\n    argv: restoreArgv,\n    cwd: context.sourcePath,\n    environment,\n    environmentPaths,\n    inputHash,\n    inputs: restoreInputs,\n    output: null,\n    pathArguments: [\n      pathArgument(1, \"source\"), pathArgument(3, \"source\"), pathArgument(5, \"build\"),\n      pathArgument(restoreArgv.length - 2, \"build\", \"--property:BaseIntermediateOutputPath=\"),\n      pathArgument(restoreArgv.length - 1, \"build\", \"--property:MSBuildProjectExtensionsPath=\")\n    ],\n    stage: \"restore\",\n    tool,\n    transientPaths: [intermediatePath]\n  })\n  const compile = checkStage({\n    argv: compileArgv,\n    cwd: context.sourcePath,\n    environment,\n    environmentPaths,\n    inputs: artifacts,\n    output: ownedOutput,\n    pathArguments: [\n      pathArgument(1, \"source\"), pathArgument(9, \"build\"),\n      pathArgument(compileArgv.length - 2, \"build\", \"--property:BaseIntermediateOutputPath=\"),\n      pathArgument(compileArgv.length - 1, \"build\", \"--property:MSBuildProjectExtensionsPath=\")\n    ],\n    stage: \"compile\",\n    tool,\n    transientPaths: [intermediatePath]\n  })\n\n  return checkPlan(context, \"csharp\", artifacts, [restore, compile])\n}\n"]}

package/build/src/backends/csharp.d.ts

@@ -1,3 +1,4 @@
+export declare const csharpProjectManifest = "<Project Sdk=\"Microsoft.NET.Sdk\">\n  <PropertyGroup>\n    <OutputType>Exe</OutputType>\n    <TargetFramework>net10.0</TargetFramework>\n    <LangVersion>14.0</LangVersion>\n    <Nullable>enable</Nullable>\n    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>\n    <WarningLevel>10</WarningLevel>\n    <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>\n    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>\n    <ImplicitUsings>disable</ImplicitUsings>\n    <EnableNETAnalyzers>false</EnableNETAnalyzers>\n    <InvariantGlobalization>true</InvariantGlobalization>\n    <PredefinedCulturesOnly>true</PredefinedCulturesOnly>\n    <Deterministic>true</Deterministic>\n    <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>\n    <DebugType>none</DebugType>\n    <UseAppHost>false</UseAppHost>\n    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>\n    <SemantifoldCompileItems Condition=\"'$(SemantifoldCompileItems)' == ''\">Program.cs</SemantifoldCompileItems>\n    <AssemblyName>Semantifold</AssemblyName>\n    <RootNamespace>Semantifold.Generated</RootNamespace>\n    <StartupObject>Semantifold.Generated.Program</StartupObject>\n    <PathMap>$(MSBuildProjectDirectory)=/_/</PathMap>\n  </PropertyGroup>\n  <ItemGroup>\n    <Compile Include=\"$(SemantifoldCompileItems)\" />\n  </ItemGroup>\n</Project>\n";
 /**
  * Emits one deterministic two-file C# project candidate.
  * @param {{filename?: string, mapDirective?: unknown, module: import("../semantic/types.js").SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} input - Backend request.

package/build/src/backends/csharp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"csharp.d.ts","sourceRoot":"","sources":["../../../src/backends/csharp.js"],"names":[],"mappings":"AAsCA;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,EAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAC,EAHvF;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,sBAAsB,EAAE,cAAc,CAAC;IAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,sBAAsB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAAA;CAGpJ,GAFrF;IAAC,SAAS,EAAE,OAAO,sBAAsB,EAAE,oBAAoB,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAsC9F"}
+{"version":3,"file":"csharp.d.ts","sourceRoot":"","sources":["../../../src/backends/csharp.js"],"names":[],"mappings":"AAQA,eAAO,MAAM,qBAAqB,6zCA6BjC,CAAA;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,EAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAC,EAHvF;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,sBAAsB,EAAE,cAAc,CAAC;IAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,sBAAsB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAAA;CAGpJ,GAFrF;IAAC,SAAS,EAAE,OAAO,sBAAsB,EAAE,oBAAoB,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAsC9F"}