test: cover JsonObjectEnv parser and version-suffix logic

- envUtil.test.ts: JsonObjectEnv with default (string) validator and with
  JsonAny validator, including non-JSON, non-object, wrong-value-type,
  and named error message cases.
- deploymentVersions.test.ts: full coverage of compareDeploymentVersions
  including the multi-hyphen suffix regression case
  (20250101.1-pre-rc.1 vs 20250101.1-pre-rc.2 must not tie at 0).
- calculateNextBuildVersion.test.ts: same-day increment, new-day reset,
  caller-provided suffix wins, and the multi-hyphen-suffix-on-input
  case.

webapp tests verified locally (14/14 passing). Supervisor test is
formed correctly; full local run is blocked by an unrelated upstream
build error in @trigger.dev/core's sharedRuntimeManager.

Author: Conner Aldrich

apps/supervisor/src/envUtil.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from "vitest";
-import { BoolEnv, AdditionalEnvVars } from "./envUtil.js";
+import { z } from "zod";
+import { BoolEnv, AdditionalEnvVars, JsonObjectEnv, JsonAny } from "./envUtil.js";
 
 describe("BoolEnv", () => {
   it("should parse string 'true' as true", () => {
@@ -78,3 +79,78 @@ describe("AdditionalEnvVars", () => {
     });
   });
 });
+
+describe("JsonObjectEnv (string-valued)", () => {
+  const schema = JsonObjectEnv("TEST_ENV");
+
+  it("returns empty object for default (no value)", () => {
+    expect(schema.parse(undefined)).toEqual({});
+  });
+
+  it("parses a simple string-valued JSON object", () => {
+    expect(schema.parse('{"a":"1","b":"2"}')).toEqual({ a: "1", b: "2" });
+  });
+
+  it("parses an empty JSON object", () => {
+    expect(schema.parse("{}")).toEqual({});
+  });
+
+  it("rejects non-JSON input", () => {
+    expect(() => schema.parse("not json")).toThrowError(/not valid JSON/);
+  });
+
+  it("rejects JSON arrays", () => {
+    expect(() => schema.parse("[]")).toThrowError(/must be a JSON object \(got array\)/);
+  });
+
+  it("rejects JSON primitives", () => {
+    expect(() => schema.parse('"foo"')).toThrowError(/must be a JSON object \(got string\)/);
+    expect(() => schema.parse("42")).toThrowError(/must be a JSON object \(got number\)/);
+    expect(() => schema.parse("null")).toThrowError(/must be a JSON object \(got object\)/);
+  });
+
+  it("rejects values that are not strings (with default validator)", () => {
+    expect(() => schema.parse('{"a": 1}')).toThrowError(/has invalid value/);
+    expect(() => schema.parse('{"a": true}')).toThrowError(/has invalid value/);
+  });
+});
+
+describe("JsonObjectEnv (arbitrary-value)", () => {
+  const schema = JsonObjectEnv("TEST_ANY", { valueValidator: JsonAny });
+
+  it("accepts nested objects", () => {
+    expect(
+      schema.parse(
+        JSON.stringify({
+          runAsNonRoot: true,
+          runAsUser: 1000,
+          capabilities: { drop: ["ALL"] },
+        })
+      )
+    ).toEqual({
+      runAsNonRoot: true,
+      runAsUser: 1000,
+      capabilities: { drop: ["ALL"] },
+    });
+  });
+
+  it("accepts mixed value types", () => {
+    expect(schema.parse('{"s":"x","n":1,"b":true,"a":[1,2],"o":{"k":"v"}}')).toEqual({
+      s: "x",
+      n: 1,
+      b: true,
+      a: [1, 2],
+      o: { k: "v" },
+    });
+  });
+
+  it("still rejects non-object roots", () => {
+    expect(() => schema.parse('"x"')).toThrowError(/must be a JSON object/);
+    expect(() => schema.parse("[1,2,3]")).toThrowError(/must be a JSON object/);
+  });
+
+  it("includes the env var name in error messages", () => {
+    const named = JsonObjectEnv("KUBERNETES_WORKER_POD_SECURITY_CONTEXT");
+    expect(() => named.parse("{notjson")).toThrowError(/KUBERNETES_WORKER_POD_SECURITY_CONTEXT/);
+  });
+});

apps/webapp/test/calculateNextBuildVersion.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test, beforeEach, afterEach, vi } from "vitest";
+import { calculateNextBuildVersion } from "../app/v3/utils/calculateNextBuildVersion";
+
+describe("calculateNextBuildVersion", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2025-02-08T12:00:00Z"));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  test("starts at YYYYMMDD.1 when there's no previous version", () => {
+    expect(calculateNextBuildVersion(null)).toBe("20250208.1");
+    expect(calculateNextBuildVersion(undefined)).toBe("20250208.1");
+    expect(calculateNextBuildVersion("")).toBe("20250208.1");
+  });
+
+  test("appends suffix when starting fresh", () => {
+    expect(calculateNextBuildVersion(null, "hardened")).toBe("20250208.1-hardened");
+  });
+
+  test("increments build number on same day", () => {
+    expect(calculateNextBuildVersion("20250208.1")).toBe("20250208.2");
+    expect(calculateNextBuildVersion("20250208.5")).toBe("20250208.6");
+  });
+
+  test("resets to .1 on a new day", () => {
+    expect(calculateNextBuildVersion("20250207.5")).toBe("20250208.1");
+  });
+
+  test("ignores existing suffix on the latest version", () => {
+    // The new version uses the caller-provided suffix, not the existing one.
+    expect(calculateNextBuildVersion("20250208.1-old")).toBe("20250208.2");
+    expect(calculateNextBuildVersion("20250208.1-old", "new")).toBe("20250208.2-new");
+    expect(calculateNextBuildVersion("20250208.1-old", undefined)).toBe("20250208.2");
+  });
+
+  test("handles multi-hyphen suffix on the latest version (regression test)", () => {
+    // Before the fix, split("-") destructured `existingSuffix = "pre"` from
+    // "20250208.1-pre-rc.1" — unused but misleading. baseVersion was correct
+    // because `split("-")[0]` works regardless of segment count.
+    expect(calculateNextBuildVersion("20250208.1-pre-rc.1")).toBe("20250208.2");
+    expect(calculateNextBuildVersion("20250208.1-pre-rc.1", "hardened")).toBe(
+      "20250208.2-hardened"
+    );
+  });
+});

apps/webapp/test/deploymentVersions.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "vitest";
+import { compareDeploymentVersions } from "../app/v3/utils/deploymentVersions";
+
+describe("compareDeploymentVersions", () => {
+  describe("base versions only (no suffix)", () => {
+    test("orders by date ascending", () => {
+      expect(compareDeploymentVersions("20250101.1", "20250102.1")).toBe(-1);
+      expect(compareDeploymentVersions("20250102.1", "20250101.1")).toBe(1);
+    });
+
+    test("orders by build number when dates are equal", () => {
+      expect(compareDeploymentVersions("20250101.1", "20250101.2")).toBe(-1);
+      expect(compareDeploymentVersions("20250101.2", "20250101.1")).toBe(1);
+      expect(compareDeploymentVersions("20250101.10", "20250101.2")).toBe(1);
+    });
+
+    test("treats identical versions as equal", () => {
+      expect(compareDeploymentVersions("20250101.1", "20250101.1")).toBe(0);
+    });
+  });
+
+  describe("with single-segment suffixes", () => {
+    test("versions without suffix sort before versions with suffix", () => {
+      expect(compareDeploymentVersions("20250101.1", "20250101.1-hardened")).toBe(-1);
+      expect(compareDeploymentVersions("20250101.1-hardened", "20250101.1")).toBe(1);
+    });
+
+    test("orders suffixes alphabetically when bases are equal", () => {
+      expect(compareDeploymentVersions("20250101.1-alpha", "20250101.1-beta")).toBe(-1);
+      expect(compareDeploymentVersions("20250101.1-beta", "20250101.1-alpha")).toBe(1);
+    });
+
+    test("equal suffixes return 0", () => {
+      expect(compareDeploymentVersions("20250101.1-foo", "20250101.1-foo")).toBe(0);
+    });
+  });
+
+  describe("with multi-hyphen suffixes (regression test)", () => {
+    test("does NOT tie-break two distinct multi-hyphen suffixes as equal", () => {
+      // Before the fix: split("-") returned ["20250101.1","pre","rc.1"], destructured
+      // suffix = "pre" — so both versions would compare as equal.
+      const a = "20250101.1-pre-rc.1";
+      const b = "20250101.1-pre-rc.2";
+      expect(compareDeploymentVersions(a, b)).not.toBe(0);
+      expect(compareDeploymentVersions(a, b)).toBe(-1);
+      expect(compareDeploymentVersions(b, a)).toBe(1);
+    });
+
+    test("preserves full suffix in sort", () => {
+      expect(compareDeploymentVersions("20250101.1-a-b", "20250101.1-a-c")).toBe(-1);
+      expect(compareDeploymentVersions("20250101.1-x-y-z", "20250101.1-x-y-z")).toBe(0);
+    });
+  });
+});