swallowkit 2.0.0-alpha.2 → 2.0.0-alpha.4

package/src/__tests__/azure-cli.test.ts

@@ -0,0 +1,199 @@
+import * as childProcess from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  buildBatchCommandLine,
+  checkAzCliAvailability,
+  resetAzCliInvocationCache,
+  resolveAzCliInvocation,
+  runAzCli,
+  setAzCliInvocationForTesting,
+} from "../utils/azure-cli";
+import { INTERACTIVE_PROVISION_RETRY_HINT, executeProvisionPlan, planProvisionOperation } from "../core/operations/provision-operations";
+import { describeProvisionAction } from "../cli/commands/provision";
+import { createMigrationManifest, saveMigrationManifest } from "../core/project/migrations";
+import { formatCliError } from "../cli";
+import { MachineCommandError } from "../machine/errors";
+
+jest.mock("child_process", () => {
+  const actual = jest.requireActual<typeof import("child_process")>("child_process");
+  return { ...actual, spawnSync: jest.fn(actual.spawnSync) };
+});
+
+const spawnSyncMock = jest.mocked(childProcess.spawnSync) as unknown as ReturnType<typeof jest.fn>;
+
+describe("Azure CLI resolution on Windows", () => {
+  let root: string;
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-az-"));
+  });
+  afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
+
+  const touch = (file: string) => {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, "");
+    return file;
+  };
+
+  it("runs the MSI install's bundled Python the same way az.cmd does", () => {
+    const wrapper = touch(path.join(root, "CLI2", "wbin", "az.cmd"));
+    touch(path.join(root, "CLI2", "wbin", "az"));
+    const python = touch(path.join(root, "CLI2", "python.exe"));
+    const invocation = resolveAzCliInvocation({ PATH: `${path.join(root, "missing")};${path.dirname(wrapper)}`, PATHEXT: ".COM;.EXE;.BAT;.CMD" }, "win32");
+    expect(invocation).toEqual({ command: python, prefixArgs: ["-IBm", "azure.cli"], env: { AZ_INSTALLER: "MSI" }, source: wrapper });
+  });
+
+  it("uses an executable directly and other batch wrappers through cmd.exe", () => {
+    const exe = touch(path.join(root, "exe", "az.exe"));
+    expect(resolveAzCliInvocation({ PATH: path.dirname(exe) }, "win32")).toEqual({ command: exe, prefixArgs: [], source: exe });
+    const bat = touch(path.join(root, "venv", "Scripts", "az.bat"));
+    expect(resolveAzCliInvocation({ PATH: path.dirname(bat), ComSpec: "C:\\Windows\\system32\\cmd.exe" }, "win32"))
+      .toEqual({ command: "C:\\Windows\\system32\\cmd.exe", prefixArgs: [], batchScript: bat, source: bat });
+  });
+
+  it("reports not found when PATH has no az, and uses az directly elsewhere", () => {
+    expect(resolveAzCliInvocation({ PATH: root }, "win32")).toBeNull();
+    expect(resolveAzCliInvocation({ PATH: "/usr/bin" }, "linux")).toEqual({ command: "az", prefixArgs: [], source: "az" });
+  });
+
+  it("quotes batch arguments and refuses values cmd.exe would reinterpret", () => {
+    expect(buildBatchCommandLine("C:\\Program Files\\az.cmd", ["deployment", "--template-file", "C:\\my app\\main.bicep", "location=japaneast"]))
+      .toBe('""C:\\Program Files\\az.cmd" "deployment" "--template-file" "C:\\my app\\main.bicep" "location=japaneast""');
+    expect(() => buildBatchCommandLine("az.cmd", ["100%"])).toThrow(/cannot be passed safely/);
+    expect(() => buildBatchCommandLine("az.cmd", ['a"b'])).toThrow(/cannot be passed safely/);
+  });
+});
+
+describe("Azure CLI invocation and availability", () => {
+  afterEach(() => {
+    resetAzCliInvocationCache();
+    spawnSyncMock.mockReset();
+    spawnSyncMock.mockImplementation(jest.requireActual<typeof import("child_process")>("child_process").spawnSync);
+  });
+
+  it("never uses a shell and prepends wrapper arguments", () => {
+    spawnSyncMock.mockReturnValue({ status: 0, stdout: "ok", stderr: "" });
+    const invocation = { command: "C:\\CLI2\\python.exe", prefixArgs: ["-IBm", "azure.cli"], env: { AZ_INSTALLER: "MSI" }, source: "az.cmd" };
+    expect(runAzCli(["group", "exists", "--name", "rg"], { invocation })).toMatchObject({ status: 0, stdout: "ok" });
+    const [command, args, options] = spawnSyncMock.mock.calls[0];
+    expect(command).toBe("C:\\CLI2\\python.exe");
+    expect(args).toEqual(["-IBm", "azure.cli", "group", "exists", "--name", "rg"]);
+    expect(options).toMatchObject({ shell: false, env: expect.objectContaining({ AZ_INSTALLER: "MSI" }) });
+  });
+
+  it("runs batch wrappers through cmd.exe with verbatim quoted arguments", () => {
+    spawnSyncMock.mockReturnValue({ status: 0, stdout: "", stderr: "" });
+    runAzCli(["--version"], { invocation: { command: "cmd.exe", prefixArgs: [], batchScript: "C:\\az.bat", source: "C:\\az.bat" } });
+    const [command, args, options] = spawnSyncMock.mock.calls[0];
+    expect(command).toBe("cmd.exe");
+    expect(args).toEqual(["/d", "/s", "/v:off", "/c", '""C:\\az.bat" "--version""']);
+    expect(options).toMatchObject({ shell: false, windowsVerbatimArguments: true });
+  });
+
+  it("distinguishes a missing CLI from one that cannot start", () => {
+    setAzCliInvocationForTesting(null);
+    expect(checkAzCliAvailability()).toEqual({ available: false, reason: "not-found", detail: "az was not found on PATH." });
+
+    setAzCliInvocationForTesting({ command: "az", prefixArgs: [], source: "az" });
+    spawnSyncMock.mockReturnValue({ status: null, stdout: "", stderr: "", error: Object.assign(new Error("spawn az ENOENT"), { code: "ENOENT" }) });
+    expect(checkAzCliAvailability()).toMatchObject({ available: false, reason: "not-found" });
+
+    spawnSyncMock.mockReturnValue({ status: 1, stdout: "", stderr: "ModuleNotFoundError: azure.cli" });
+    expect(checkAzCliAvailability()).toMatchObject({ available: false, reason: "not-runnable", detail: expect.stringContaining("ModuleNotFoundError") });
+
+    spawnSyncMock.mockReturnValue({ status: 0, stdout: "azure-cli 2.70.0", stderr: "" });
+    expect(checkAzCliAvailability()).toMatchObject({ available: true });
+  });
+});
+
+describe("provision planning with Azure CLI state", () => {
+  const originalCwd = process.cwd();
+  let project: string;
+  beforeEach(() => {
+    project = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-provision-az-"));
+    fs.mkdirSync(path.join(project, "infra"), { recursive: true });
+    fs.writeFileSync(path.join(project, "infra", "main.bicep"), "targetScope = 'resourceGroup'\n");
+    fs.writeFileSync(path.join(project, "infra", "main.parameters.json"), JSON.stringify({ parameters: { projectName: { value: "sample" } } }));
+    saveMigrationManifest(createMigrationManifest(project, { projectId: "project" }), project);
+    process.chdir(project);
+    setAzCliInvocationForTesting({ command: "az", prefixArgs: [], source: "az" });
+  });
+  afterEach(() => {
+    process.chdir(originalCwd);
+    resetAzCliInvocationCache();
+    spawnSyncMock.mockReset();
+    spawnSyncMock.mockImplementation(jest.requireActual<typeof import("child_process")>("child_process").spawnSync);
+    fs.rmSync(project, { recursive: true, force: true });
+  });
+
+  const options = { resourceGroup: "rg-sample", location: "japaneast", swaLocation: "eastasia" };
+
+  it("reads Azure state through the resolved CLI and plans a bootstrap", async () => {
+    spawnSyncMock.mockImplementation((_command: string, args: string[]) => {
+      if (args[0] === "--version") return { status: 0, stdout: "azure-cli", stderr: "" };
+      if (args[0] === "group" && args[1] === "exists") return { status: 0, stdout: "false\n", stderr: "" };
+      return { status: 1, stdout: "", stderr: `unexpected ${args.join(" ")}` };
+    });
+    const plan = await planProvisionOperation(options);
+    expect(plan.azCliAvailable).toBe(true);
+    expect(plan.mode).toBe("bootstrap");
+    expect(plan.warnings.filter((warning) => warning.startsWith("az-"))).toEqual([]);
+    expect(spawnSyncMock.mock.calls.every((call: unknown[]) => (call[2] as { shell?: boolean }).shell === false)).toBe(true);
+  });
+
+  const plansDir = () => path.join(project, ".swallowkit", "state", "plans");
+  const savedPlans = () => (fs.existsSync(plansDir()) ? fs.readdirSync(plansDir()) : []);
+
+  it("keeps the interactive preview in memory and re-checks Azure before running it", async () => {
+    let groupExists = false;
+    spawnSyncMock.mockImplementation((_command: string, args: string[]) => {
+      if (args[0] === "--version") return { status: 0, stdout: "azure-cli", stderr: "" };
+      if (args[0] === "group" && args[1] === "exists") return { status: 0, stdout: `${groupExists}\n`, stderr: "" };
+      if (args[0] === "group" && args[1] === "show") return { status: 0, stdout: JSON.stringify({ id: "/subscriptions/test/resourceGroups/rg-sample", tags: {} }), stderr: "" };
+      return { status: 1, stdout: "", stderr: `unexpected ${args.join(" ")}` };
+    });
+    const preview = await planProvisionOperation(options, { persist: false });
+    expect(savedPlans()).toEqual([]);
+    expect(describeProvisionAction(preview)).toBe(
+      "Resource group rg-sample does not exist yet. It will be created in japaneast and the infrastructure in infra/main.bicep will be deployed."
+    );
+
+    groupExists = true;
+    await expect(executeProvisionPlan(preview, { approve: true, retryHint: INTERACTIVE_PROVISION_RETRY_HINT })).rejects.toMatchObject({
+      code: "stale-azure-state",
+      message: 'The resource group was created after the preview was computed. Run "swallowkit provision" again to review the current state.',
+    });
+    expect(spawnSyncMock.mock.calls.some((call: unknown[]) => (call[1] as string[])[0] === "group" && (call[1] as string[])[1] === "create")).toBe(false);
+  });
+
+  it("still saves plans for the machine plan/apply workflow", async () => {
+    spawnSyncMock.mockImplementation((_command: string, args: string[]) => args[0] === "--version"
+      ? { status: 0, stdout: "azure-cli", stderr: "" }
+      : { status: 0, stdout: "false\n", stderr: "" });
+    const plan = await planProvisionOperation(options);
+    expect(savedPlans().some((file) => file.includes(plan.planId))).toBe(true);
+  });
+
+  it("asks for az login instead of reporting a missing CLI", async () => {
+    spawnSyncMock.mockImplementation((_command: string, args: string[]) => args[0] === "--version"
+      ? { status: 0, stdout: "azure-cli", stderr: "" }
+      : { status: 1, stdout: "", stderr: "ERROR: Please run 'az login' to setup account." });
+    await expect(planProvisionOperation(options)).rejects.toMatchObject({ code: "az-not-logged-in", status: "requires-human" });
+  });
+
+  it("reports an installed but broken CLI accurately", async () => {
+    spawnSyncMock.mockReturnValue({ status: 1, stdout: "", stderr: "Failed to load python executable." });
+    const plan = await planProvisionOperation(options);
+    expect(plan.mode).toBe("offline");
+    expect(plan.warnings.some((warning) => warning.startsWith("az-cli-not-runnable:") && warning.includes("Failed to load python executable."))).toBe(true);
+  });
+});
+
+describe("regular CLI error output", () => {
+  it("prints machine errors without a stack trace", () => {
+    const text = formatCliError(new MachineCommandError("online-plan-required", "Cannot apply.", { nextAction: "Run az login." }, "blocked"));
+    expect(text).toBe("❌ Cannot apply.\n   (code: online-plan-required)\n   Next: Run az login.");
+    expect(formatCliError(new Error("plain failure"))).toBe("❌ plain failure");
+  });
+});

package/src/__tests__/boundaries.test.ts

@@ -0,0 +1,42 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { inspectBoundaries } from "../core/project/boundaries";
+import { buildSwallowKitConfigSource } from "../cli/commands/init";
+import type { BackendLanguage } from "../types";
+
+describe("inspect boundaries convention rules", () => {
+  let project: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(() => {
+    project = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-boundaries-"));
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(project, { recursive: true, force: true });
+  });
+
+  it.each<BackendLanguage>(["csharp", "python", "typescript"])("matches the %s backend", (language) => {
+    const contract = inspectBoundaries(project, language);
+    expect(contract.backendLanguage).toBe(language);
+    expect(contract.conventionRules).toMatchSnapshot();
+    expect(contract.conventionRules.some((rule) => rule.pattern === "functions/function_app.py")).toBe(language === "python");
+  });
+
+  it("resolves the backend language from swallowkit.config", () => {
+    fs.writeFileSync(path.join(project, "swallowkit.config.js"), buildSwallowKitConfigSource("csharp", "react"));
+    process.chdir(project);
+    const contract = inspectBoundaries(project);
+    expect(contract.backendLanguage).toBe("csharp");
+    expect(contract.conventionRules.map((rule) => rule.pattern)).not.toContain("functions/function_app.py");
+  });
+
+  it("orders specific infrastructure rules before the baseline rule", () => {
+    const patterns = inspectBoundaries(project, "typescript").conventionRules.map((rule) => rule.pattern);
+    expect(patterns.indexOf("infra/migrations/manifest.json")).toBeLessThan(patterns.indexOf("infra/migrations/"));
+    expect(patterns.indexOf("infra/migrations/")).toBeLessThan(patterns.indexOf("infra/"));
+    expect(patterns[patterns.length - 1]).toBe("*");
+  });
+});

package/src/__tests__/csharp-schema.test.ts

@@ -0,0 +1,261 @@
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import * as z from "zod/v4";
+import { FileOperationSession } from "../core/operations/file-session";
+import { parseModelFile } from "../core/scaffold/model-parser";
+import { generateLanguageSchemaArtifacts } from "../core/scaffold/native-schema-generator";
+import { generateOpenApiDocument } from "../core/scaffold/openapi-generator";
+
+const MODEL_SOURCE = `import { z } from 'zod/v4';
+export const ProbeItem = z.object({
+  id: z.string(),
+  userId: z.string(),
+  title: z.string().min(1).max(40),
+  code: z.string().regex(/^[a-z]+-\\d+$/i).optional(),
+  tags: z.array(z.string().min(2)).max(3),
+  score: z.number().min(0).max(1),
+  count: z.number().int().nonnegative(),
+  kind: z.enum(['a', 'b']),
+  nested: z.object({ x: z.string(), depth: z.object({ level: z.number().int() }).optional() }).optional(),
+  publishedAt: z.iso.datetime().optional(),
+  note: z.string().nullable(),
+  rating: z.number().gt(0).min(0).lt(5).max(5).nullable(),
+  items: z.array(z.object({ x: z.string().min(1) })).optional(),
+  kinds: z.array(z.enum(['a', 'b'])).optional(),
+  metadata: z.object({}).optional(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+export type ProbeItem = z.infer<typeof ProbeItem>;
+export const partitionKey = '/userId';
+export const displayName = 'Probe';
+`;
+
+// Same schema as MODEL_SOURCE; used to validate C# output exactly as the BFF responseSchema would.
+const ProbeItem = z.object({
+  id: z.string(),
+  userId: z.string(),
+  title: z.string().min(1).max(40),
+  code: z.string().regex(/^[a-z]+-\d+$/i).optional(),
+  tags: z.array(z.string().min(2)).max(3),
+  score: z.number().min(0).max(1),
+  count: z.number().int().nonnegative(),
+  kind: z.enum(["a", "b"]),
+  nested: z.object({ x: z.string(), depth: z.object({ level: z.number().int() }).optional() }).optional(),
+  publishedAt: z.iso.datetime().optional(),
+  note: z.string().nullable(),
+  rating: z.number().gt(0).min(0).lt(5).max(5).nullable(),
+  items: z.array(z.object({ x: z.string().min(1) })).optional(),
+  kinds: z.array(z.enum(["a", "b"])).optional(),
+  metadata: z.object({}).optional(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+
+const VALID_INPUTS = [
+  {
+    id: "1",
+    userId: "user-1",
+    title: "Probe",
+    code: "ABC-12",
+    tags: ["aa", "bb"],
+    score: 0.25,
+    count: 3,
+    kind: "b",
+    nested: { x: "value", depth: { level: 2 } },
+    publishedAt: "2024-05-06T07:08:09.123Z",
+    note: "note",
+    rating: 2.5,
+    items: [{ x: "a" }, { x: "b" }],
+    kinds: ["a", "b"],
+    metadata: {},
+    createdAt: "2024-05-06T07:08:09.123456+09:00",
+    updatedAt: "not a timestamp but still a string",
+  },
+  { id: "2", userId: "user-2", title: "Minimal", tags: [], score: 1, count: 0, kind: "a", note: null, rating: null },
+];
+
+const INVALID_INPUTS: Array<{ input: Record<string, unknown>; members: string[] }> = [
+  { input: { ...VALID_INPUTS[1], title: "" }, members: ["title"] },
+  { input: { ...VALID_INPUTS[1], title: "x".repeat(41) }, members: ["title"] },
+  { input: { ...VALID_INPUTS[1], code: "no-digits" }, members: ["code"] },
+  { input: { ...VALID_INPUTS[1], tags: ["a"] }, members: ["tags[0]"] },
+  { input: { ...VALID_INPUTS[1], tags: ["aa", "bb", "cc", "dd"] }, members: ["tags"] },
+  { input: { ...VALID_INPUTS[1], score: 1.5 }, members: ["score"] },
+  { input: { ...VALID_INPUTS[1], count: -1 }, members: ["count"] },
+  { input: { ...VALID_INPUTS[1], nested: { depth: { level: 1 } } }, members: ["nested.x"] },
+  { input: { ...VALID_INPUTS[1], rating: 0 }, members: ["rating"] },
+  { input: { ...VALID_INPUTS[1], rating: 5 }, members: ["rating"] },
+  { input: { ...VALID_INPUTS[1], items: [{ x: "ok" }, { x: "" }] }, members: ["items[1].x"] },
+];
+
+function createModel(): { root: string; modelPath: string } {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-csharp-schema-"));
+  const modelPath = path.join(root, "shared", "models", "probe-item.ts");
+  fs.mkdirSync(path.dirname(modelPath), { recursive: true });
+  fs.writeFileSync(modelPath, MODEL_SOURCE);
+  return { root, modelPath };
+}
+
+describe("Zod -> OpenAPI -> C# conversion", () => {
+  let root: string;
+  let modelPath: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(() => {
+    ({ root, modelPath } = createModel());
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it("records formats, integers, constraints, and inline object shapes from Zod", async () => {
+    const model = await parseModelFile(modelPath);
+    const field = (name: string) => model.fields.find((candidate) => candidate.name === name)!;
+    expect(model.parserMode).toBe("static-ast");
+    expect(field("createdAt")).toMatchObject({ type: "string", isOptional: true });
+    expect(field("createdAt").format).toBeUndefined();
+    expect(field("publishedAt").format).toBe("date-time");
+    expect(field("title").constraints).toEqual({ minLength: 1, maxLength: 40 });
+    expect(field("code").constraints).toEqual({ pattern: "^[a-z]+-\\d+$", patternFlags: "i" });
+    expect(field("tags").constraints).toEqual({ minLength: 2, maxItems: 3 });
+    expect(field("score")).toMatchObject({ constraints: { minimum: 0, maximum: 1 } });
+    expect(field("score").isInteger).toBeUndefined();
+    expect(field("count")).toMatchObject({ isInteger: true, constraints: { minimum: 0 } });
+    expect(field("nested").objectFields?.map((child) => child.name)).toEqual(["x", "depth"]);
+    expect(field("nested").objectFields?.[1].objectFields?.[0]).toMatchObject({ name: "level", isInteger: true });
+    expect(field("rating")).toMatchObject({
+      isNullable: true,
+      constraints: { minimum: 0, exclusiveMinimum: true, maximum: 5, exclusiveMaximum: true },
+    });
+    expect(field("metadata").objectFields).toEqual([]);
+  });
+
+  it("emits typed OpenAPI components without guessing formats from names", async () => {
+    const model = await parseModelFile(modelPath);
+    const schemas = JSON.parse(generateOpenApiDocument([model], model)).components.schemas;
+    const properties = schemas.ProbeItem.properties;
+    expect(properties.createdAt).toEqual({ type: "string" });
+    expect(properties.publishedAt).toEqual({ type: "string", format: "date-time" });
+    expect(properties.score).toEqual({ type: "number", format: "double", minimum: 0, maximum: 1 });
+    expect(properties.count).toEqual({ type: "integer", format: "int64", minimum: 0 });
+    expect(properties.title).toEqual({ type: "string", minLength: 1, maxLength: 40 });
+    expect(properties.code).toEqual({ type: "string", pattern: "^[a-z]+-\\d+$" });
+    expect(properties.tags).toEqual({ type: "array", items: { type: "string", minLength: 2 }, maxItems: 3 });
+    expect(properties.nested).toEqual({ $ref: "#/components/schemas/ProbeItemNested" });
+    expect(schemas.ProbeItemNested).toEqual({
+      type: "object",
+      properties: { x: { type: "string" }, depth: { $ref: "#/components/schemas/ProbeItemNestedDepth" } },
+      required: ["x"],
+    });
+    expect(schemas.ProbeItemNestedDepth.properties.level).toEqual({ type: "integer", format: "int64" });
+  });
+
+  it("generates C# types and validation from the Zod contract", async () => {
+    const model = await parseModelFile(modelPath);
+    process.chdir(root);
+    await generateLanguageSchemaArtifacts([model], model, "functions", "csharp", new FileOperationSession("commit", root));
+    const modelDir = path.join(root, "functions", "generated", "csharp-models", "src", "SwallowKitBackendModels", "Model");
+    const source = fs.readFileSync(path.join(modelDir, "ProbeItem.cs"), "utf8");
+
+    expect(source).toContain("public string? CreatedAt");
+    expect(source).toContain("public DateTime? PublishedAt");
+    expect(source).toContain("public double Score");
+    expect(source).toContain("public long Count");
+    expect(source).toContain("public ProbeItemNested? Nested");
+    expect(source).not.toMatch(/Dictionary<string, object>|decimal|DateTime\? CreatedAt/);
+    expect(source).not.toContain("yield break;");
+    expect(source).toContain('Title.Length < 1');
+    expect(source).toContain('Regex.IsMatch(Code, "^[a-z]+-\\\\d+$", RegexOptions.IgnoreCase)');
+    expect(source).toContain("Score > 1");
+    expect(source).toContain("Count < 0");
+    expect(fs.readFileSync(path.join(modelDir, "ProbeItemNested.cs"), "utf8")).toContain("public ProbeItemNestedDepth? Depth");
+    expect(fs.readFileSync(path.join(modelDir, "ProbeItemNestedDepth.cs"), "utf8")).toContain("public long Level");
+    expect(source).toContain("public string? Note");
+    expect(source).not.toContain("if (Note is null)");
+    expect(source).toContain("public double? Rating");
+    expect(source).toContain("Rating.HasValue && Rating.Value <= 0");
+    expect(source).toContain("public List<ProbeItemItems>? Items");
+    expect(source).toContain("public List<KindsEnum>? Kinds");
+    const metadata = fs.readFileSync(path.join(modelDir, "ProbeItemMetadata.cs"), "utf8");
+    expect(metadata.match(/public ProbeItemMetadata\(\)/g)).toHaveLength(1);
+  });
+});
+
+const dotnetVersion = spawnSync("dotnet", ["--version"], { encoding: "utf8" });
+const itWithDotnet = dotnetVersion.status === 0 ? it : it.skip;
+
+describe("generated C# JSON round trip", () => {
+  itWithDotnet("serializes back to JSON that passes the same Zod schema, and rejects what Zod rejects", async () => {
+    const { root, modelPath } = createModel();
+    const originalCwd = process.cwd();
+    try {
+      const model = await parseModelFile(modelPath);
+      process.chdir(root);
+      await generateLanguageSchemaArtifacts([model], model, "functions", "csharp", new FileOperationSession("commit", root));
+      process.chdir(originalCwd);
+
+      const app = path.join(root, "roundtrip");
+      fs.mkdirSync(app);
+      const major = String(dotnetVersion.stdout).trim().split(".")[0];
+      fs.writeFileSync(path.join(app, "RoundTrip.csproj"), `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net${major}.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="../functions/generated/csharp-models/**/*.cs" />
+  </ItemGroup>
+</Project>
+`);
+      fs.writeFileSync(path.join(app, "Program.cs"), `using System.ComponentModel.DataAnnotations;
+using System.Text.Json;
+using SwallowKitBackendModels.Model;
+
+var results = new List<object>();
+foreach (var file in args)
+{
+    var item = JsonSerializer.Deserialize<ProbeItem>(File.ReadAllText(file))!;
+    var errors = new List<ValidationResult>();
+    Validator.TryValidateObject(item, new ValidationContext(item), errors, true);
+    results.Add(new { json = JsonSerializer.Serialize(item), members = errors.SelectMany(error => error.MemberNames).ToArray() });
+}
+Console.WriteLine(JsonSerializer.Serialize(results));
+`);
+      const inputs = [...VALID_INPUTS, ...INVALID_INPUTS.map((entry) => entry.input)];
+      const files = inputs.map((input, index) => {
+        const file = path.join(root, `input-${index}.json`);
+        fs.writeFileSync(file, JSON.stringify(input));
+        return file;
+      });
+      const run = spawnSync("dotnet", ["run", "--project", app, "--", ...files], {
+        encoding: "utf8",
+        timeout: 240000,
+        env: { ...process.env, DOTNET_CLI_TELEMETRY_OPTOUT: "1", DOTNET_NOLOGO: "1" },
+      });
+      if (run.status !== 0) throw new Error(`dotnet run failed (${run.status}):\n${run.stdout}\n${run.stderr}`);
+      const output = JSON.parse(run.stdout.trim().split(/\r?\n/).pop()!) as Array<{ json: string; members: string[] }>;
+
+      VALID_INPUTS.forEach((input, index) => {
+        expect(ProbeItem.safeParse(input).success).toBe(true);
+        expect(output[index].members).toEqual([]);
+        const roundTripped = JSON.parse(output[index].json);
+        expect(ProbeItem.safeParse(roundTripped).success).toBe(true);
+        expect(roundTripped).toEqual(input);
+      });
+      INVALID_INPUTS.forEach(({ input, members }, offset) => {
+        expect(ProbeItem.safeParse(input).success).toBe(false);
+        expect(output[VALID_INPUTS.length + offset].members).toEqual(members);
+      });
+    } finally {
+      process.chdir(originalCwd);
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  }, 300000);
+});

package/src/__tests__/dev.test.ts

@@ -32,6 +32,7 @@ describe("dev command helpers", () => {
 
   it("passes the requested port to Azure Functions Core Tools", () => {
     expect(buildFunctionsStartArgs("7076")).toEqual(["start", "--port", "7076"]);
+    expect(buildFunctionsStartArgs("7076", "csharp")).toEqual(["--port", "7076"]);
   });
 
   it("parses the Core Tools version from CLI output", () => {
@@ -47,16 +48,22 @@ describe("dev command helpers", () => {
   it("falls back to npm Core Tools for older C# isolated hosts", () => {
     expect(buildFunctionsCoreToolsCommand("csharp", "4.0.5198")).toEqual({
       command: "npm",
-      argsPrefix: ["exec", "--yes", "azure-functions-core-tools@4", "--"],
-      label: "npm exec azure-functions-core-tools@4 (installed func 4.0.5198 is too old for C# isolated)",
+      argsPrefix: ["exec", "--yes", "--package", "azure-functions-core-tools@4", "--", "dotnet", "run", "--no-launch-profile", "--"],
+      label: "dotnet run with npm azure-functions-core-tools@4 (installed func 4.0.5198 is too old for C# isolated)",
     });
   });
 
-  it("keeps the installed func command for supported Core Tools versions", () => {
+  it("uses the .NET SDK launch target for C# so extensions load from the output directory", () => {
     expect(buildFunctionsCoreToolsCommand("csharp", "4.6.0")).toEqual({
-      command: "func",
-      argsPrefix: [],
-      label: "func 4.6.0",
+      command: "dotnet",
+      argsPrefix: ["run", "--no-launch-profile", "--"],
+      label: "dotnet run",
+    });
+  });
+
+  it.each(["typescript", "python"] as const)("keeps func start for %s", language => {
+    expect(buildFunctionsCoreToolsCommand(language, "4.14.0")).toEqual({
+      command: "func", argsPrefix: [], label: "func 4.14.0",
     });
   });
 

package/src/__tests__/home-page.test.ts

@@ -0,0 +1,50 @@
+import { buildHomePage } from "../core/project/home-page";
+import { adaptReactPage } from "../core/scaffold/react-ui-generator";
+
+describe("shared home page presentation", () => {
+  it.each(["npm", "pnpm"] as const)(
+    "differs only in framework label and routing with %s",
+    (pm) => {
+      const next = buildHomePage("nextjs", pm);
+      const react = buildHomePage("react", pm);
+      const adaptedNext = adaptReactPage(next)
+        .replace("export const dynamic = 'force-dynamic';\n\n", "")
+        .replace("Next.js on Azure", "React on Azure");
+
+      expect(react).toBe(adaptedNext);
+      expect(react).toContain("Welcome to SwallowKit");
+      expect(react).toContain("Your Models");
+      expect(react).toContain("Get Started");
+      expect(react).toContain("Built with SwallowKit");
+      expect(react).toContain(
+        `${pm === "npm" ? "npx" : "pnpm exec"} swallowkit scaffold shared/models/your-model.ts`
+      );
+    }
+  );
+
+  it("keeps Next.js-only directives out of the SPA", () => {
+    const next = buildHomePage("nextjs", "pnpm");
+    const react = buildHomePage("react", "pnpm");
+
+    expect(next).toContain("'use client'");
+    expect(next).toContain("export const dynamic = 'force-dynamic'");
+    expect(next).toContain("href={model.path}");
+    expect(react).not.toMatch(/next\/|use client|force-dynamic/);
+    expect(react).toContain("import { Link } from 'react-router-dom'");
+    expect(react).toContain("to={model.path}");
+  });
+
+  it.each(["nextjs", "react"] as const)(
+    "preserves connection states and same-origin requests for %s",
+    (frontend) => {
+      const source = buildHomePage(frontend, "pnpm");
+      expect(source).toContain("fetch('/api/greet?name=SwallowKit')");
+      expect(source).toContain("disabled={greetingStatus === 'loading'}");
+      expect(source).toContain("setGreetingStatus('success')");
+      expect(source).toContain("setGreetingStatus('error')");
+      expect(source).toContain('role="status"');
+      expect(source).toContain('role="alert"');
+      expect(source).not.toMatch(/BACKEND_FUNCTIONS_|VITE_/);
+    }
+  );
+});