@interf/compiler 0.22.2 → 0.33.0

package/dist/packages/runtime/actions/form-validators.js

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import { ActionValueIdPattern, actionIdField, optionalActionIdField, optionalActionText, requiredActionText, } from "./schemas.js";
+import { maybeActionValue } from "./helpers.js";
+void ActionValueIdPattern;
+export function createProjectSchema(existingNames) {
+    return z.object({
+        name: actionIdField("Project name"),
+        path: requiredActionText("Source"),
+        build_plan: optionalActionIdField("Build Plan").optional(),
+    }).strict().superRefine((values, ctx) => {
+        if (existingNames.has(values.name)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["name"],
+                message: "A Project with this name already exists.",
+            });
+        }
+    });
+}
+export function prepareRunSchema() {
+    return z.object({
+        project: actionIdField("Project"),
+        build_plan: optionalActionIdField("Build Plan"),
+        source_folder_path: optionalActionText,
+    }).strict();
+}
+export function selectBuildPlanSchema() {
+    return z.object({
+        name: actionIdField("Project"),
+        path: requiredActionText("Source"),
+        current_build_plan: optionalActionIdField("Current Build Plan"),
+        build_plan: actionIdField("Build Plan"),
+    }).strict();
+}
+export function buildPlanAuthoringSchema(existingBuildPlanIds) {
+    return z.object({
+        build_plan_id: optionalActionIdField("Build Plan id"),
+        label: optionalActionText,
+        hint: optionalActionText,
+        intent: requiredActionText("Intent"),
+        requested_artifacts_description: optionalActionText,
+        user_prep_instructions: optionalActionText,
+    }).strict().superRefine((values, ctx) => {
+        const explicitBuildPlanId = maybeActionValue(values.build_plan_id ?? "");
+        if (explicitBuildPlanId && existingBuildPlanIds.has(explicitBuildPlanId)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["build_plan_id"],
+                message: "A Build Plan with this id already exists.",
+            });
+        }
+    });
+}
+export function buildPlanChangeSchema(action, buildPlanId, existingBuildPlanIds) {
+    const base = {
+        action: requiredActionText("Action"),
+        build_plan: actionIdField("Build Plan"),
+        project: optionalActionIdField("Project"),
+    };
+    if (action === "modify") {
+        return z.object({
+            ...base,
+            change_request: requiredActionText("Requested change"),
+            label: optionalActionText,
+            hint: optionalActionText,
+        }).strict();
+    }
+    if (action === "duplicate") {
+        return z.object({
+            ...base,
+            new_build_plan_id: actionIdField("New Build Plan id"),
+        }).strict().superRefine((values, ctx) => {
+            if (existingBuildPlanIds.has(values.new_build_plan_id)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ["new_build_plan_id"],
+                    message: "A Build Plan with this id already exists.",
+                });
+            }
+        });
+    }
+    return z.object({
+        ...base,
+        confirmation: requiredActionText("Confirmation").refine((value) => value === buildPlanId, `Type ${buildPlanId} to confirm.`),
+    }).strict();
+}
+export function projectChangeSchema(action, project, existingNames) {
+    const base = {
+        action: requiredActionText("Action"),
+        project: actionIdField("Project"),
+    };
+    if (action === "modify") {
+        return z.object({
+            ...base,
+            name: actionIdField("Project id"),
+            path: requiredActionText("Source"),
+            build_plan: optionalActionIdField("Build Plan"),
+        }).strict().superRefine((values, ctx) => {
+            if (values.name !== project && existingNames.has(values.name)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ["name"],
+                    message: "A Project with this name already exists.",
+                });
+            }
+        });
+    }
+    if (action === "duplicate") {
+        return z.object({
+            ...base,
+            name: actionIdField("New Project id"),
+            path: requiredActionText("Source"),
+            build_plan: optionalActionIdField("Build Plan"),
+        }).strict().superRefine((values, ctx) => {
+            if (existingNames.has(values.name)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ["name"],
+                    message: "A Project with this name already exists.",
+                });
+            }
+        });
+    }
+    return z.object({
+        ...base,
+        confirmation: requiredActionText("Confirmation").refine((value) => value === project, `Type ${project} to confirm.`),
+    }).strict();
+}

package/dist/packages/runtime/actions/helpers.d.ts

@@ -0,0 +1,11 @@
+import { type BuildPlanAuthoringActionValues } from "./schemas.js";
+import type { ActionFieldOption, ActionInputValues, BuildPlanActionChoice } from "./fields.js";
+export declare function buildPlanAuthoringIntentBrief(values: BuildPlanAuthoringActionValues): string;
+export declare function slugForActionId(value: string): string;
+export declare function uniqueActionId(seed: string, usedIds: Set<string>): string;
+export declare function titleFromActionId(value: string): string;
+export declare function maybeActionValue(value: string): string | undefined;
+export declare function inputValue(values: ActionInputValues, key: string): string;
+export declare function buildPlanChoiceOptions(buildPlans: BuildPlanActionChoice[]): ActionFieldOption[];
+export declare function buildPlanIntentFromInput(values: ActionInputValues): string;
+export declare function conciseSummary(value: string, fallback: string): string;

package/dist/packages/runtime/actions/helpers.js

@@ -0,0 +1,80 @@
+import { formatRequestedArtifactsForPrompt } from "../requested-artifacts.js";
+import { BuildPlanAuthoringActionValuesSchema, } from "./schemas.js";
+export function buildPlanAuthoringIntentBrief(values) {
+    const requestedArtifacts = values.requested_artifacts?.length
+        ? formatRequestedArtifactsForPrompt(values.requested_artifacts)
+        : null;
+    const requestedArtifactsDescription = values.requested_artifacts_description?.trim();
+    const prepInstructions = values.user_prep_instructions?.trim();
+    return [
+        `Intent: ${values.intent}`,
+        requestedArtifacts ? `Requested Artifacts:\n${requestedArtifacts}` : null,
+        requestedArtifactsDescription ? `Requested Artifacts: ${requestedArtifactsDescription}` : null,
+        prepInstructions ? `Build instructions: ${prepInstructions}` : null,
+    ].filter((line) => Boolean(line)).join("\n");
+}
+export function slugForActionId(value) {
+    const slug = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 72)
+        .replace(/-+$/g, "");
+    return slug || "project";
+}
+export function uniqueActionId(seed, usedIds) {
+    const base = slugForActionId(seed);
+    if (!usedIds.has(base))
+        return base;
+    for (let index = 2; index < 100; index += 1) {
+        const candidate = `${base}-${index}`;
+        if (!usedIds.has(candidate))
+            return candidate;
+    }
+    return `${base}-${Date.now().toString(36)}`;
+}
+export function titleFromActionId(value) {
+    return value
+        .split("-")
+        .filter(Boolean)
+        .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+        .join(" ");
+}
+export function maybeActionValue(value) {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+export function inputValue(values, key) {
+    return values[key] ?? "";
+}
+export function buildPlanChoiceOptions(buildPlans) {
+    const seen = new Set();
+    const options = [];
+    for (const buildPlan of [{ id: "interf-default", label: "interf-default" }, ...buildPlans]) {
+        if (seen.has(buildPlan.id))
+            continue;
+        seen.add(buildPlan.id);
+        options.push({ label: buildPlan.label ?? buildPlan.id, value: buildPlan.id });
+    }
+    return options;
+}
+export function buildPlanIntentFromInput(values) {
+    const parsed = BuildPlanAuthoringActionValuesSchema.safeParse(values);
+    if (parsed.success)
+        return buildPlanAuthoringIntentBrief(parsed.data);
+    const intent = inputValue(values, "intent");
+    const requestedArtifactsDescription = inputValue(values, "requested_artifacts_description");
+    const prepInstructions = inputValue(values, "user_prep_instructions");
+    return [
+        `Intent: ${intent}`,
+        maybeActionValue(requestedArtifactsDescription) ? `Requested Artifacts: ${requestedArtifactsDescription}` : null,
+        maybeActionValue(prepInstructions) ? `Build instructions: ${prepInstructions}` : null,
+    ].filter((line) => Boolean(line)).join("\n");
+}
+export function conciseSummary(value, fallback) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (!normalized)
+        return fallback;
+    const sentence = normalized.match(/^.{24,180}?(?:[.!?](?:\s|$)|$)/)?.[0]?.trim() ?? normalized;
+    return sentence.length > 180 ? `${sentence.slice(0, 177).trim()}...` : sentence;
+}

package/dist/packages/runtime/actions/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./schemas.js";
+export * from "./registry.js";
+export * from "./fields.js";
+export * from "./errors.js";
+export * from "./helpers.js";
+export * from "./form-validators.js";
+export * from "./requests.js";
+export * from "./form-builders.js";

package/dist/packages/runtime/actions/index.js

@@ -0,0 +1,11 @@
+// Aggregate barrel for engine action definitions. Re-exports the public
+// surface so existing callers (UI page.tsx, CLI commands, action-values.ts)
+// don't have to know which sibling file owns a given symbol.
+export * from "./schemas.js";
+export * from "./registry.js";
+export * from "./fields.js";
+export * from "./errors.js";
+export * from "./helpers.js";
+export * from "./form-validators.js";
+export * from "./requests.js";
+export * from "./form-builders.js";

package/dist/packages/runtime/actions/registry.d.ts

@@ -0,0 +1,64 @@
+export declare const INTERF_SERVICE_ACTIONS: {
+    readonly createProject: {
+        readonly id: "create-project";
+        readonly serviceAction: "project-setup";
+        readonly title: "Create Project";
+        readonly description: "Save a Source, Build Plan, and Project activity under one Project.";
+    };
+    readonly buildRun: {
+        readonly id: "build-run";
+        readonly serviceAction: "build";
+        readonly title: "Build Context Graph";
+        readonly description: "Run the saved Build Plan against this Source and write a Context Graph.";
+    };
+    readonly selectBuildPlan: {
+        readonly id: "select-build-plan";
+        readonly serviceAction: "project-setup";
+        readonly title: "Select Build Plan";
+        readonly description: "Choose the Build Plan that will build this Project's Context Graph.";
+    };
+    readonly createBuildPlan: {
+        readonly id: "build-plan-draft";
+        readonly serviceAction: "build-plan-draft";
+        readonly title: "Draft Build Plan";
+        readonly description: "Draft a Build Plan for the Context Graph this Project should build.";
+    };
+    readonly buildPlanChange: {
+        readonly id: "build-plan-change";
+        readonly serviceAction: "build-plan-change";
+        readonly title: "Modify Build Plan";
+        readonly description: "Modify, duplicate, or remove an existing Build Plan.";
+    };
+    readonly projectChange: {
+        readonly id: "project-change";
+        readonly serviceAction: "project-change";
+        readonly title: "Modify Project";
+        readonly description: "Modify, duplicate, or remove an existing Project.";
+    };
+    readonly confirmAction: {
+        readonly id: "confirm-action";
+        readonly serviceAction: "action-proposal";
+        readonly title: "Confirm Request";
+        readonly description: "Confirm the typed Interf service request before it runs.";
+    };
+    readonly runBenchmark: {
+        readonly id: "run-benchmark";
+        readonly serviceAction: "benchmark";
+        readonly title: "Run Benchmark";
+        readonly description: "Run saved Q&A / fact-check evaluation questions against this Project.";
+    };
+    readonly draftBenchmarkQuestions: {
+        readonly id: "draft-benchmark-questions";
+        readonly serviceAction: "benchmark-question-draft";
+        readonly title: "Draft Benchmark Questions";
+        readonly description: "Ask the configured local executor to draft saved Q&A / fact-check evaluation questions.";
+    };
+    readonly improveProject: {
+        readonly id: "improve-project";
+        readonly serviceAction: "build-plan-improvement";
+        readonly title: "Improve Build Plan";
+        readonly description: "Use benchmark results and Build evidence to refine the Build Plan this Project uses.";
+    };
+};
+export type InterfServiceActionKey = keyof typeof INTERF_SERVICE_ACTIONS;
+export type InterfServiceActionId = typeof INTERF_SERVICE_ACTIONS[InterfServiceActionKey]["id"];

package/dist/packages/runtime/actions/registry.js

@@ -0,0 +1,62 @@
+export const INTERF_SERVICE_ACTIONS = {
+    createProject: {
+        id: "create-project",
+        serviceAction: "project-setup",
+        title: "Create Project",
+        description: "Save a Source, Build Plan, and Project activity under one Project.",
+    },
+    buildRun: {
+        id: "build-run",
+        serviceAction: "build",
+        title: "Build Context Graph",
+        description: "Run the saved Build Plan against this Source and write a Context Graph.",
+    },
+    selectBuildPlan: {
+        id: "select-build-plan",
+        serviceAction: "project-setup",
+        title: "Select Build Plan",
+        description: "Choose the Build Plan that will build this Project's Context Graph.",
+    },
+    createBuildPlan: {
+        id: "build-plan-draft",
+        serviceAction: "build-plan-draft",
+        title: "Draft Build Plan",
+        description: "Draft a Build Plan for the Context Graph this Project should build.",
+    },
+    buildPlanChange: {
+        id: "build-plan-change",
+        serviceAction: "build-plan-change",
+        title: "Modify Build Plan",
+        description: "Modify, duplicate, or remove an existing Build Plan.",
+    },
+    projectChange: {
+        id: "project-change",
+        serviceAction: "project-change",
+        title: "Modify Project",
+        description: "Modify, duplicate, or remove an existing Project.",
+    },
+    confirmAction: {
+        id: "confirm-action",
+        serviceAction: "action-proposal",
+        title: "Confirm Request",
+        description: "Confirm the typed Interf service request before it runs.",
+    },
+    runBenchmark: {
+        id: "run-benchmark",
+        serviceAction: "benchmark",
+        title: "Run Benchmark",
+        description: "Run saved Q&A / fact-check evaluation questions against this Project.",
+    },
+    draftBenchmarkQuestions: {
+        id: "draft-benchmark-questions",
+        serviceAction: "benchmark-question-draft",
+        title: "Draft Benchmark Questions",
+        description: "Ask the configured local executor to draft saved Q&A / fact-check evaluation questions.",
+    },
+    improveProject: {
+        id: "improve-project",
+        serviceAction: "build-plan-improvement",
+        title: "Improve Build Plan",
+        description: "Use benchmark results and Build evidence to refine the Build Plan this Project uses.",
+    },
+};

package/dist/packages/runtime/actions/requests.d.ts

@@ -0,0 +1,45 @@
+import { artifactRequirementsFromRequestedArtifacts } from "../requested-artifacts.js";
+import type { RequestedArtifact, SourceContext, BuildPlanContextCheckDraft } from "../../build-plans/authoring/brief.js";
+import { type BuildPlanAuthoringActionValues, type ProjectSetupActionValues } from "./schemas.js";
+import type { ActionInputValues, ActionValues, BuildPlanChangeAction, ProjectChangeAction } from "./fields.js";
+export declare function normalizedBuildPlanActionValues(values: ActionInputValues, existingBuildPlanIds: Set<string>, defaultSeed: string): ActionInputValues;
+export declare function createProjectActionValues(values: ActionInputValues): ProjectSetupActionValues;
+export declare function selectBuildPlanActionValues(values: ActionInputValues): ProjectSetupActionValues;
+export declare function projectSetupRequestFromActionValues(input: unknown): {
+    project: {
+        build_plan?: string;
+        name: string;
+        path: string;
+    };
+    build_after_setup: boolean;
+    setup_mode: "create" | "select-build-plan";
+};
+export declare function buildPlanAuthoringRequestFromActionValues(input: unknown, context: {
+    checks?: BuildPlanContextCheckDraft[];
+    project?: string | null;
+    requestedArtifacts?: RequestedArtifact[];
+    sourceContext?: SourceContext | null;
+}): {
+    artifact_requirements: ReturnType<typeof artifactRequirementsFromRequestedArtifacts>;
+    base_build_plan_id?: string;
+    checks: BuildPlanContextCheckDraft[];
+    hint?: string;
+    label: string;
+    build_plan_id: string;
+    project?: string;
+    reference_build_plan_id?: string;
+    requested_artifacts: RequestedArtifact[];
+    source_context?: SourceContext | null;
+    intent: string;
+    user_prep_instructions?: string;
+};
+export declare function buildPlanImprovementActionValues(options: {
+    hint?: string;
+    label?: string;
+    buildPlanId: string;
+    projectName: string;
+}): BuildPlanAuthoringActionValues;
+export declare function buildPlanAuthoringActionValues(values: ActionInputValues): BuildPlanAuthoringActionValues;
+export declare function buildPlanChangeActionValues(action: BuildPlanChangeAction, values: ActionInputValues): ActionValues;
+export declare function duplicateProjectActionValues(values: ActionInputValues): ProjectSetupActionValues;
+export declare function projectChangeActionValues(action: ProjectChangeAction, values: ActionInputValues): ActionValues;

package/dist/packages/runtime/actions/requests.js

@@ -0,0 +1,158 @@
+import { artifactRequirementsFromRequestedArtifacts, } from "../requested-artifacts.js";
+import { BuildPlanAuthoringActionValuesSchema, ProjectSetupActionValuesSchema, } from "./schemas.js";
+import { conciseSummary, inputValue, maybeActionValue, titleFromActionId, uniqueActionId, } from "./helpers.js";
+export function normalizedBuildPlanActionValues(values, existingBuildPlanIds, defaultSeed) {
+    const explicitBuildPlanId = maybeActionValue(inputValue(values, "build_plan_id"));
+    const intent = inputValue(values, "intent").trim();
+    const buildPlanId = explicitBuildPlanId ?? uniqueActionId(intent || defaultSeed || "custom-build-plan", existingBuildPlanIds);
+    const output = maybeActionValue(inputValue(values, "requested_artifacts_description"));
+    return {
+        ...values,
+        build_plan_id: buildPlanId,
+        label: maybeActionValue(inputValue(values, "label")) ?? titleFromActionId(buildPlanId),
+        hint: maybeActionValue(inputValue(values, "hint")) ?? conciseSummary(output ?? intent, "Build Plan for requested Artifacts and Context Checks."),
+        intent,
+    };
+}
+export function createProjectActionValues(values) {
+    const buildPlan = inputValue(values, "build_plan");
+    return {
+        name: inputValue(values, "name"),
+        path: inputValue(values, "path"),
+        build_after_setup: false,
+        ...(maybeActionValue(buildPlan) ? { build_plan: buildPlan } : {}),
+    };
+}
+export function selectBuildPlanActionValues(values) {
+    return {
+        name: inputValue(values, "name"),
+        path: inputValue(values, "path"),
+        build_plan: inputValue(values, "build_plan"),
+        build_after_setup: false,
+        setup_mode: "select-build-plan",
+    };
+}
+export function projectSetupRequestFromActionValues(input) {
+    const values = ProjectSetupActionValuesSchema.parse(input);
+    const buildPlan = values.build_plan;
+    return {
+        build_after_setup: values.build_after_setup ?? false,
+        setup_mode: values.setup_mode === "select-build-plan" ? "select-build-plan" : "create",
+        project: {
+            name: values.name,
+            path: values.path,
+            ...(buildPlan && buildPlan.length > 0 ? { build_plan: buildPlan } : {}),
+        },
+    };
+}
+export function buildPlanAuthoringRequestFromActionValues(input, context) {
+    const values = BuildPlanAuthoringActionValuesSchema.parse(input);
+    const buildPlanId = values.build_plan_id;
+    if (!buildPlanId) {
+        throw new Error("Build Plan id is required.");
+    }
+    const requestedArtifacts = values.requested_artifacts ?? context.requestedArtifacts ?? [];
+    const sourceContext = values.source_context ?? context.sourceContext ?? null;
+    const baseBuildPlanId = values.base_build_plan_id;
+    const referenceBuildPlanId = values.reference_build_plan_id;
+    return {
+        ...(context.project ? { project: context.project } : {}),
+        ...(baseBuildPlanId ? { base_build_plan_id: baseBuildPlanId } : {}),
+        ...(referenceBuildPlanId ? { reference_build_plan_id: referenceBuildPlanId } : {}),
+        build_plan_id: buildPlanId,
+        label: values.label ?? titleFromActionId(buildPlanId),
+        ...(values.hint ? { hint: values.hint } : { hint: conciseSummary(values.requested_artifacts_description ?? values.intent, "Reusable Build Plan for building Artifacts.") }),
+        intent: values.intent,
+        checks: values.checks ?? context.checks ?? [],
+        ...(values.user_prep_instructions ? { user_prep_instructions: values.user_prep_instructions } : {}),
+        requested_artifacts: requestedArtifacts,
+        source_context: sourceContext,
+        artifact_requirements: artifactRequirementsFromRequestedArtifacts(requestedArtifacts),
+    };
+}
+export function buildPlanImprovementActionValues(options) {
+    return {
+        build_plan_id: options.buildPlanId,
+        reference_build_plan_id: options.buildPlanId,
+        ...(maybeActionValue(options.label ?? "") ? { label: options.label } : {}),
+        ...(maybeActionValue(options.hint ?? "") ? { hint: options.hint } : {}),
+        intent: `Improve Build Plan ${options.buildPlanId} using the latest benchmark results and Build evidence for Project ${options.projectName}.`,
+    };
+}
+export function buildPlanAuthoringActionValues(values) {
+    const buildPlanId = inputValue(values, "build_plan_id");
+    const label = inputValue(values, "label");
+    const hint = inputValue(values, "hint");
+    const requestedArtifactsDescription = inputValue(values, "requested_artifacts_description");
+    const userPrepInstructions = inputValue(values, "user_prep_instructions");
+    return {
+        ...(maybeActionValue(buildPlanId) ? { build_plan_id: buildPlanId } : {}),
+        ...(maybeActionValue(label) ? { label } : {}),
+        ...(maybeActionValue(hint) ? { hint } : {}),
+        intent: inputValue(values, "intent"),
+        ...(maybeActionValue(requestedArtifactsDescription) ? { requested_artifacts_description: requestedArtifactsDescription } : {}),
+        ...(maybeActionValue(userPrepInstructions) ? { user_prep_instructions: userPrepInstructions } : {}),
+    };
+}
+export function buildPlanChangeActionValues(action, values) {
+    if (action === "modify") {
+        const buildPlanId = inputValue(values, "build_plan");
+        return {
+            build_plan_id: buildPlanId,
+            reference_build_plan_id: buildPlanId,
+            ...(maybeActionValue(inputValue(values, "label")) ? { label: inputValue(values, "label") } : {}),
+            ...(maybeActionValue(inputValue(values, "hint")) ? { hint: inputValue(values, "hint") } : {}),
+            intent: [
+                `Modify Build Plan ${buildPlanId}.`,
+                inputValue(values, "change_request"),
+            ].filter(Boolean).join("\n"),
+        };
+    }
+    if (action === "duplicate") {
+        const newBuildPlanId = inputValue(values, "new_build_plan_id");
+        return {
+            action_type: "build-plan-change",
+            operation: "duplicate",
+            build_plan: inputValue(values, "build_plan"),
+            new_build_plan_id: newBuildPlanId,
+            label: titleFromActionId(newBuildPlanId),
+            hint: `Duplicate of ${inputValue(values, "build_plan")}`,
+        };
+    }
+    return {
+        action_type: "build-plan-change",
+        operation: "remove",
+        build_plan: inputValue(values, "build_plan"),
+        confirmation: inputValue(values, "confirmation"),
+    };
+}
+export function duplicateProjectActionValues(values) {
+    const buildPlan = inputValue(values, "build_plan");
+    return {
+        name: inputValue(values, "name"),
+        path: inputValue(values, "path"),
+        build_after_setup: false,
+        setup_mode: "create",
+        ...(maybeActionValue(buildPlan) ? { build_plan: buildPlan } : {}),
+    };
+}
+export function projectChangeActionValues(action, values) {
+    if (action === "modify") {
+        const buildPlan = inputValue(values, "build_plan");
+        return {
+            name: inputValue(values, "project"),
+            path: inputValue(values, "path"),
+            build_after_setup: false,
+            setup_mode: "select-build-plan",
+            ...(maybeActionValue(buildPlan) ? { build_plan: buildPlan } : {}),
+        };
+    }
+    if (action === "duplicate")
+        return duplicateProjectActionValues(values);
+    return {
+        action_type: "project-change",
+        operation: "remove",
+        project: inputValue(values, "project"),
+        confirmation: inputValue(values, "confirmation"),
+    };
+}