@jiggai/kitchen 0.3.1 → 0.3.3

package/src/components/__tests__/FileListWithOptionalToggle.test.tsx

@@ -1,109 +0,0 @@
-import { describe, expect, it, vi, afterEach } from "vitest";
-import { render, screen, fireEvent, cleanup } from "@testing-library/react";
-
-afterEach(cleanup);
-import { FileListWithOptionalToggle } from "../FileListWithOptionalToggle";
-
-const files = [
-  { name: "SOUL.md", missing: false, required: true },
-  { name: "AGENTS.md", missing: true, required: false },
-  { name: "USER.md", missing: false, required: false },
-];
-
-describe("FileListWithOptionalToggle", () => {
-  it("renders title and file list", () => {
-    render(
-      <FileListWithOptionalToggle
-        title="Agent files"
-        files={files}
-        showOptionalFiles={true}
-        onShowOptionalChange={vi.fn()}
-        selectedFileName=""
-        onSelectFile={vi.fn()}
-      />
-    );
-    expect(screen.getByText("Agent files")).toBeTruthy();
-    expect(screen.getByText("SOUL.md")).toBeTruthy();
-    expect(screen.getByText("AGENTS.md")).toBeTruthy();
-    expect(screen.getByText("USER.md")).toBeTruthy();
-  });
-
-  it("filters optional missing files when showOptionalFiles is false", () => {
-    const { container } = render(
-      <FileListWithOptionalToggle
-        title="Filtered Files"
-        files={files}
-        showOptionalFiles={false}
-        onShowOptionalChange={vi.fn()}
-        selectedFileName=""
-        onSelectFile={vi.fn()}
-      />
-    );
-    expect(container.textContent).toContain("SOUL.md");
-    expect(container.textContent).toContain("USER.md");
-    expect(container.textContent).not.toContain("AGENTS.md");
-  });
-
-  it("shows all files when showOptionalFiles is true", () => {
-    const { container } = render(
-      <FileListWithOptionalToggle
-        title="All Files"
-        files={files}
-        showOptionalFiles={true}
-        onShowOptionalChange={vi.fn()}
-        selectedFileName=""
-        onSelectFile={vi.fn()}
-      />
-    );
-    expect(container.textContent).toContain("AGENTS.md");
-  });
-
-  it("calls onSelectFile when file clicked", () => {
-    const onSelectFile = vi.fn();
-    render(
-      <FileListWithOptionalToggle
-        title="Click Files"
-        files={files}
-        showOptionalFiles={true}
-        onShowOptionalChange={vi.fn()}
-        selectedFileName=""
-        onSelectFile={onSelectFile}
-      />
-    );
-    const buttons = screen.getAllByRole("button");
-    const soulButton = buttons.find((b) => b.textContent?.includes("SOUL.md"));
-    fireEvent.click(soulButton!);
-    expect(onSelectFile).toHaveBeenCalledWith("SOUL.md");
-  });
-
-  it("calls onShowOptionalChange when checkbox toggled", () => {
-    const onShowOptionalChange = vi.fn();
-    render(
-      <FileListWithOptionalToggle
-        title="Files"
-        files={files}
-        showOptionalFiles={false}
-        onShowOptionalChange={onShowOptionalChange}
-        selectedFileName=""
-        onSelectFile={vi.fn()}
-      />
-    );
-    fireEvent.click(screen.getByRole("checkbox"));
-    expect(onShowOptionalChange).toHaveBeenCalledWith(true);
-  });
-
-  it("shows Loading… when loading", () => {
-    render(
-      <FileListWithOptionalToggle
-        title="Files"
-        files={[]}
-        loading={true}
-        showOptionalFiles={true}
-        onShowOptionalChange={vi.fn()}
-        selectedFileName=""
-        onSelectFile={vi.fn()}
-      />
-    );
-    expect(screen.getByText("Loading…")).toBeTruthy();
-  });
-});

package/src/components/__tests__/GoalFormFields.test.tsx

@@ -1,117 +0,0 @@
-import { describe, expect, it, vi, afterEach } from "vitest";
-import { render, screen, fireEvent, cleanup } from "@testing-library/react";
-
-afterEach(cleanup);
-import { GoalFormCard, GoalFormFields, type GoalFormState } from "../GoalFormFields";
-
-function makeFormState(overrides?: Partial<GoalFormState>): GoalFormState {
-  return {
-    title: "",
-    setTitle: vi.fn(),
-    status: "planned",
-    setStatus: vi.fn(),
-    tagsRaw: "",
-    setTagsRaw: vi.fn(),
-    teamsRaw: "",
-    setTeamsRaw: vi.fn(),
-    body: "",
-    setBody: vi.fn(),
-    ...overrides,
-  };
-}
-
-describe("GoalFormCard", () => {
-  it("renders children and actions", () => {
-    render(
-      <GoalFormCard error={null} actions={<button>Save</button>}>
-        <div data-testid="child">Form content</div>
-      </GoalFormCard>
-    );
-    expect(screen.getByTestId("child").textContent).toBe("Form content");
-    expect(screen.getByRole("button", { name: "Save" })).toBeTruthy();
-  });
-
-  it("shows error when provided", () => {
-    render(
-      <GoalFormCard error="Something went wrong" actions={<button>Save</button>}>
-        <div>Content</div>
-      </GoalFormCard>
-    );
-    expect(screen.getByText("Something went wrong")).toBeTruthy();
-  });
-
-  it("hides error when null", () => {
-    render(
-      <GoalFormCard error={null} actions={<button>Save</button>}>
-        <div data-testid="content">Content</div>
-      </GoalFormCard>
-    );
-    expect(screen.getByTestId("content")).toBeTruthy();
-    expect(screen.queryByText("Something went wrong")).toBeNull();
-  });
-});
-
-describe("GoalFormFields", () => {
-  it("renders title, status, tags, teams, body inputs", () => {
-    const formState = makeFormState({ title: "My goal", body: "Body text" });
-    render(<GoalFormFields formState={formState} />);
-
-    expect((screen.getByPlaceholderText("Goal title") as HTMLInputElement).value).toBe("My goal");
-    const textarea = screen.getByPlaceholderText("Write the goal here…");
-    expect((textarea as HTMLTextAreaElement).value).toBe("Body text");
-    expect(screen.getByRole("combobox")).toBeTruthy();
-  });
-
-  it("renders id field when idField provided", () => {
-    const setId = vi.fn();
-    const formState = makeFormState();
-    render(
-      <GoalFormFields
-        formState={formState}
-        idField={{ id: "my-id", setId, suggestedId: "suggested-id" }}
-      />
-    );
-    expect((screen.getByPlaceholderText("increase-trial-activation") as HTMLInputElement).value).toBe("my-id");
-  });
-
-  it("shows suggested id button when id is empty", () => {
-    const setId = vi.fn();
-    const formState = makeFormState();
-    render(
-      <GoalFormFields
-        formState={formState}
-        idField={{ id: "", setId, suggestedId: "suggested-id" }}
-      />
-    );
-    expect(screen.getByText("suggested-id")).toBeTruthy();
-  });
-
-  it("clicking suggested id button calls setId", () => {
-    const setId = vi.fn();
-    const formState = makeFormState();
-    render(
-      <GoalFormFields
-        formState={formState}
-        idField={{ id: "", setId, suggestedId: "suggested-id" }}
-      />
-    );
-    fireEvent.click(screen.getByText("suggested-id"));
-    expect(setId).toHaveBeenCalledWith("suggested-id");
-  });
-
-  it("calls setTitle when title input changes", () => {
-    const setTitle = vi.fn();
-    const formState = makeFormState({ setTitle });
-    render(<GoalFormFields formState={formState} />);
-    fireEvent.change(screen.getByPlaceholderText("Goal title"), { target: { value: "x" } });
-    expect(setTitle).toHaveBeenCalledWith("x");
-  });
-
-  it("calls setStatus when status select changes", () => {
-    const setStatus = vi.fn();
-    const formState = makeFormState({ setStatus });
-    render(<GoalFormFields formState={formState} />);
-    fireEvent.change(screen.getByRole("combobox"), { target: { value: "active" } });
-    expect(setStatus).toHaveBeenCalledWith("active");
-  });
-});

package/src/components/delete-modals.tsx

@@ -1,59 +0,0 @@
-"use client";
-
-import { DeleteEntityModal } from "./DeleteEntityModal";
-
-type EntityLabelKey = "agentId" | "teamId" | "recipeId" | "jobLabel";
-
-type BaseProps = {
-  open: boolean;
-  onClose: () => void;
-  onConfirm: () => void;
-  busy?: boolean;
-  error?: string | null;
-};
-
-function createDeleteModal<K extends EntityLabelKey>(config: {
-  title: string;
-  bodyText: string;
-  entityLabelKey: K;
-}) {
-  return function DeleteModal(props: BaseProps & Record<K, string>) {
-    const entityLabel = props[config.entityLabelKey];
-    return (
-      <DeleteEntityModal
-        open={props.open}
-        onClose={props.onClose}
-        title={config.title}
-        entityLabel={entityLabel}
-        bodyText={config.bodyText}
-        onConfirm={props.onConfirm}
-        busy={props.busy}
-        error={props.error}
-      />
-    );
-  };
-}
-
-export const DeleteAgentModal = createDeleteModal({
-  title: "Delete agent",
-  bodyText: "This will remove its workspace/state.",
-  entityLabelKey: "agentId",
-});
-
-export const DeleteTeamModal = createDeleteModal({
-  title: "Delete Team",
-  bodyText: "This will remove the team workspace, agents, and stamped cron jobs.",
-  entityLabelKey: "teamId",
-});
-
-export const DeleteRecipeModal = createDeleteModal({
-  title: "Delete recipe",
-  bodyText: "This removes the markdown file from your workspace.",
-  entityLabelKey: "recipeId",
-});
-
-export const DeleteCronJobModal = createDeleteModal({
-  title: "Delete cron job",
-  bodyText: "This removes it from the Gateway scheduler. You can recreate it later.",
-  entityLabelKey: "jobLabel",
-});

package/src/components/icons.tsx

@@ -1,48 +0,0 @@
-"use client";
-
-function IconSvg({ className, children }: { className?: string; children: React.ReactNode }) {
-  return (
-    <svg
-      className={className}
-      viewBox="0 0 24 24"
-      fill="none"
-      xmlns="http://www.w3.org/2000/svg"
-      aria-hidden="true"
-    >
-      {children}
-    </svg>
-  );
-}
-
-export function SunIcon({ className }: { className?: string }) {
-  return (
-    <IconSvg className={className}>
-      <path
-        d="M12 18a6 6 0 1 0 0-12 6 6 0 0 0 0 12Z"
-        stroke="currentColor"
-        strokeWidth="1.8"
-      />
-      <path d="M12 2v2.5" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" />
-      <path d="M12 19.5V22" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" />
-      <path d="M2 12h2.5" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" />
-      <path d="M19.5 12H22" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" />
-      <path d="M4.2 4.2 6 6" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" />
-      <path d="M18 18l1.8 1.8" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" />
-      <path d="M18 6l1.8-1.8" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" />
-      <path d="M4.2 19.8 6 18" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" />
-    </IconSvg>
-  );
-}
-
-export function MoonIcon({ className }: { className?: string }) {
-  return (
-    <IconSvg className={className}>
-      <path
-        d="M21 14.2A7.8 7.8 0 0 1 9.8 3a7 7 0 1 0 11.2 11.2Z"
-        stroke="currentColor"
-        strokeWidth="1.8"
-        strokeLinejoin="round"
-      />
-    </IconSvg>
-  );
-}

package/src/lib/__tests__/agent-workspace.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseTeamRoleWorkspace } from "../agent-workspace";
-
-describe("agent-workspace", () => {
-  describe("parseTeamRoleWorkspace", () => {
-    it("returns teamRole for valid workspace path", () => {
-      const ws = "/home/user/.openclaw/workspace-myteam/roles/lead";
-      const result = parseTeamRoleWorkspace(ws);
-      expect(result).toEqual({
-        kind: "teamRole",
-        teamDir: "/home/user/.openclaw/workspace-myteam",
-        teamId: "myteam",
-        roleDir: "/home/user/.openclaw/workspace-myteam/roles/lead",
-        role: "lead",
-      });
-    });
-
-    it("returns teamRole with trailing slash", () => {
-      const ws = "/path/workspace-team1/roles/dev/";
-      const result = parseTeamRoleWorkspace(ws);
-      expect(result).toEqual({
-        kind: "teamRole",
-        teamDir: "/path/workspace-team1",
-        teamId: "team1",
-        roleDir: "/path/workspace-team1/roles/dev",
-        role: "dev",
-      });
-    });
-
-    it("returns other for non-team-role path", () => {
-      expect(parseTeamRoleWorkspace("/some/other/path")).toEqual({ kind: "other" });
-      expect(parseTeamRoleWorkspace("/workspace-x/agents/y")).toEqual({ kind: "other" });
-      expect(parseTeamRoleWorkspace("")).toEqual({ kind: "other" });
-    });
-
-    it("normalizes backslashes to forward slashes", () => {
-      const ws = "C:\\Users\\x\\.openclaw\\workspace-t1\\roles\\lead";
-      const result = parseTeamRoleWorkspace(ws);
-      expect(result.kind).toBe("teamRole");
-      expect((result as { teamId: string }).teamId).toBe("t1");
-      expect((result as { role: string }).role).toBe("lead");
-    });
-  });
-});

package/src/lib/__tests__/agents.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { resolveAgentWorkspace } from "../agents";
-
-vi.mock("../openclaw", () => ({ runOpenClaw: vi.fn() }));
-
-import { runOpenClaw } from "../openclaw";
-
-describe("agents", () => {
-  beforeEach(() => {
-    vi.mocked(runOpenClaw).mockReset();
-  });
-
-  describe("resolveAgentWorkspace", () => {
-    it("returns workspace when agent found", async () => {
-      vi.mocked(runOpenClaw).mockResolvedValue({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([{ id: "a1", workspace: "/ws/a1" }]),
-        stderr: "",
-      });
-      expect(await resolveAgentWorkspace("a1")).toBe("/ws/a1");
-    });
-
-    it("throws when agent not found", async () => {
-      vi.mocked(runOpenClaw).mockResolvedValue({
-        ok: true,
-        exitCode: 0,
-        stdout: JSON.stringify([{ id: "other" }]),
-        stderr: "",
-      });
-      await expect(resolveAgentWorkspace("missing")).rejects.toThrow(
-        "Agent workspace not found for missing"
-      );
-    });
-  });
-});

package/src/lib/__tests__/api-route-helpers.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import {
-  getTeamContextFromQuery,
-  getTeamContextFromBody,
-  jsonOkRest,
-  listWorkspaceFiles,
-  installSkillErrorResponse,
-  parseJsonBody,
-} from "../api-route-helpers";
-
-vi.mock("@/lib/paths", () => ({
-  readOpenClawConfig: vi.fn(),
-  teamDirFromBaseWorkspace: vi.fn((base: string, teamId: string) => `${base}/../workspace-${teamId}`),
-}));
-
-import { readOpenClawConfig } from "@/lib/paths";
-import fs from "node:fs/promises";
-
-vi.mock("node:fs/promises", () => ({
-  default: { stat: vi.fn() },
-}));
-
-describe("api-route-helpers", () => {
-  beforeEach(() => {
-    vi.mocked(readOpenClawConfig).mockReset();
-  });
-
-  describe("getTeamContextFromQuery", () => {
-    it("returns 400 when teamId missing", async () => {
-      const res = await getTeamContextFromQuery(new Request("https://test/api/teams/files"));
-      expect(res).toBeInstanceOf(Response);
-      expect((res as Response).status).toBe(400);
-      const json = await (res as Response).json();
-      expect(json.error).toBe("teamId is required");
-    });
-
-    it("returns 500 when workspace not set", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({});
-      const res = await getTeamContextFromQuery(new Request("https://test?teamId=my-team"));
-      expect(res).toBeInstanceOf(Response);
-      expect((res as Response).status).toBe(500);
-      const json = await (res as Response).json();
-      expect(json.error).toBe("agents.defaults.workspace not set");
-    });
-
-    it("returns team context when valid", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        agents: { defaults: { workspace: "/home/x/agents" } },
-      });
-      const res = await getTeamContextFromQuery(new Request("https://test?teamId=my-team"));
-      expect(res).not.toBeInstanceOf(Response);
-      expect(res).toEqual({
-        teamId: "my-team",
-        teamDir: "/home/x/agents/../workspace-my-team",
-      });
-    });
-  });
-
-  describe("parseJsonBody", () => {
-    it("returns body object when JSON valid", async () => {
-      const req = new Request("https://test", {
-        method: "POST",
-        body: JSON.stringify({ teamId: "t1", x: 1 }),
-        headers: { "content-type": "application/json" },
-      });
-      const result = await parseJsonBody(req);
-      expect(result).not.toBeInstanceOf(Response);
-      expect((result as { body: Record<string, unknown> }).body).toEqual({ teamId: "t1", x: 1 });
-    });
-
-    it("returns 400 when JSON invalid", async () => {
-      const req = new Request("https://test", {
-        method: "POST",
-        body: "not json",
-        headers: { "content-type": "application/json" },
-      });
-      const result = await parseJsonBody(req);
-      expect(result).toBeInstanceOf(Response);
-      expect((result as Response).status).toBe(400);
-      const json = await (result as Response).json();
-      expect(json.error).toBe("Invalid JSON");
-    });
-  });
-
-  describe("jsonOkRest", () => {
-    it("returns NextResponse.json with ok:true and rest of object", async () => {
-      const res = jsonOkRest({ ok: true, path: "/a/b", workflow: { id: "w1", name: "W" } });
-      expect(res.status).toBe(200);
-      const json = await res.json();
-      expect(json.ok).toBe(true);
-      expect(json.path).toBe("/a/b");
-      expect(json.workflow).toEqual({ id: "w1", name: "W" });
-    });
-
-    it("omits ok from rest when input has ok:false", async () => {
-      const res = jsonOkRest({ ok: false, error: "x" });
-      const json = await res.json();
-      expect(json.ok).toBe(true);
-      expect(json.error).toBe("x");
-    });
-  });
-
-  describe("installSkillErrorResponse", () => {
-    it("returns 500 JSON with error from stderr", async () => {
-      const res = installSkillErrorResponse(
-        ["recipes", "install-skill", "foo", "--agent-id", "a1", "--yes"],
-        { stdout: "out", stderr: "err", exitCode: 1 }
-      );
-      expect(res.status).toBe(500);
-      const json = await res.json();
-      expect(json.ok).toBe(false);
-      expect(json.error).toBe("err");
-      expect(json.stdout).toBe("out");
-      expect(json.stderr).toBe("err");
-    });
-
-    it("falls back to stdout when stderr empty", async () => {
-      const res = installSkillErrorResponse(["recipes", "install-skill", "x"], { stdout: "stdout", stderr: "", exitCode: 2 });
-      const json = await res.json();
-      expect(json.error).toBe("stdout");
-    });
-
-    it("includes extra fields when provided", async () => {
-      const res = installSkillErrorResponse(["x"], { stdout: "", stderr: "fail" }, { scopeArgs: ["a", "b"] });
-      const json = await res.json();
-      expect(json.scopeArgs).toEqual(["a", "b"]);
-    });
-  });
-
-  describe("getTeamContextFromBody", () => {
-    it("returns 400 when teamId missing", async () => {
-      const res = await getTeamContextFromBody({});
-      expect(res).toBeInstanceOf(Response);
-      expect((res as Response).status).toBe(400);
-    });
-
-    it("returns team context when valid", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        agents: { defaults: { workspace: "/ws" } },
-      });
-      const res = await getTeamContextFromBody({ teamId: "t1" });
-      expect(res).toEqual({ teamId: "t1", teamDir: "/ws/../workspace-t1" });
-    });
-  });
-
-  describe("listWorkspaceFiles", () => {
-    beforeEach(() => {
-      vi.mocked(fs.stat).mockReset();
-    });
-
-    it("returns file info for existing files", async () => {
-      vi.mocked(fs.stat).mockResolvedValue({ size: 100, mtimeMs: 123 } as never);
-
-      const result = await listWorkspaceFiles("/base", [
-        { name: "a.md", required: true, rationale: "A" },
-        { name: "b.md", required: false, rationale: "B" },
-      ]);
-
-      expect(result).toHaveLength(2);
-      expect(result[0]).toEqual({
-        name: "a.md",
-        required: true,
-        rationale: "A",
-        path: "/base/a.md",
-        missing: false,
-        size: 100,
-        updatedAtMs: 123,
-      });
-      expect(result[1].missing).toBe(false);
-    });
-
-    it("marks missing files", async () => {
-      vi.mocked(fs.stat).mockRejectedValue(new Error("ENOENT"));
-
-      const result = await listWorkspaceFiles("/base", [
-        { name: "missing.md", required: true, rationale: "M" },
-      ]);
-
-      expect(result[0]).toEqual({
-        name: "missing.md",
-        required: true,
-        rationale: "M",
-        path: "/base/missing.md",
-        missing: true,
-      });
-    });
-  });
-});

package/src/lib/__tests__/cron.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { cronJobId, cronJobLabel, fmtCronSchedule } from "../cron";
-
-describe("cronJobId", () => {
-  it("returns id when present", () => {
-    expect(cronJobId({ id: "j1" })).toBe("j1");
-  });
-
-  it("returns jobId when id missing", () => {
-    expect(cronJobId({ jobId: "j2" })).toBe("j2");
-  });
-
-  it("returns empty string when both missing", () => {
-    expect(cronJobId({})).toBe("");
-  });
-});
-
-describe("cronJobLabel", () => {
-  it("returns name when present", () => {
-    expect(cronJobLabel({ name: "Daily sync" })).toBe("Daily sync");
-  });
-
-  it("falls back to id then jobId", () => {
-    expect(cronJobLabel({ id: "j1" })).toBe("j1");
-    expect(cronJobLabel({ jobId: "j2" })).toBe("j2");
-  });
-
-  it("returns (unnamed) when all missing", () => {
-    expect(cronJobLabel({})).toBe("(unnamed)");
-  });
-});
-
-describe("fmtCronSchedule", () => {
-  it("returns cron expr when kind is cron", () => {
-    expect(fmtCronSchedule({ kind: "cron", expr: "0 * * * *" })).toBe("0 * * * *");
-  });
-
-  it("returns minutes when kind is every and everyMs", () => {
-    expect(fmtCronSchedule({ kind: "every", everyMs: 300000 })).toBe("every 5m");
-  });
-
-  it("returns empty for undefined", () => {
-    expect(fmtCronSchedule(undefined)).toBe("");
-  });
-});

package/src/lib/__tests__/editor-utils.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { normalizeFileListEntries } from "../editor-utils";
-
-describe("editor-utils", () => {
-  describe("normalizeFileListEntries", () => {
-    it("normalizes file list entries", () => {
-      const input = [
-        { name: "TEAM.md", missing: false, required: true, rationale: "Overview" },
-        { name: "X.md", missing: true, required: false },
-      ];
-      const result = normalizeFileListEntries(input);
-      expect(result).toEqual([
-        { name: "TEAM.md", missing: false, required: true, rationale: "Overview" },
-        { name: "X.md", missing: true, required: false, rationale: undefined },
-      ]);
-    });
-
-    it("handles empty array", () => {
-      expect(normalizeFileListEntries([])).toEqual([]);
-    });
-
-    it("coerces non-string name to string", () => {
-      const result = normalizeFileListEntries([{ name: 123 }]);
-      expect(result[0].name).toBe("123");
-    });
-
-    it("coerces null/undefined to empty string", () => {
-      const result = normalizeFileListEntries([{}]);
-      expect(result[0].name).toBe("");
-    });
-
-    it("treats missing/required as boolean", () => {
-      const result = normalizeFileListEntries([{ name: "x", missing: "yes", required: 1 }]);
-      expect(result[0].missing).toBe(true);
-      expect(result[0].required).toBe(true);
-    });
-  });
-});