veryfront 0.1.502 → 0.1.504

package/src/cli/commands/merge/command.ts

@@ -7,7 +7,8 @@
  * @module cli/commands/merge
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import { cliLogger } from "../../utils/index.js";
 import { cwd } from "../../../src/platform/index.js";
 import { type ApiClient, createApiClient, resolveConfigWithAuth } from "../../shared/config.js";
@@ -16,19 +17,23 @@ import { confirmPrompt, logInfo, logSuccess } from "../../utils/index.js";
 import { createSpinner } from "../../ui/index.js";
 
 /**
- * Zod schema for merge command arguments
+ * Schema factory for merge command arguments
  */
-export const MergeArgsSchema = z.object({
-  branch: z.string().min(1, "Branch name is required"),
-  into: z.string().min(1).optional(),
-  dryRun: z.boolean().default(false),
-  force: z.boolean().default(false),
-});
+export const getMergeArgsSchema = defineSchema((v) =>
+  v.object({
+    branch: v.string().min(1, "Branch name is required"),
+    into: v.string().min(1).optional(),
+    dryRun: v.boolean().default(false),
+    force: v.boolean().default(false),
+  })
+);
+
+export const MergeArgsSchema = getMergeArgsSchema();
 
 /**
  * Merge command options (inferred from schema)
  */
-export type MergeOptions = z.infer<typeof MergeArgsSchema>;
+export type MergeOptions = InferSchema<ReturnType<typeof getMergeArgsSchema>>;
 
 /**
  * Parse CLI arguments into validated MergeOptions

package/src/cli/commands/open/command.ts

@@ -1,13 +1,18 @@
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import { createArgParser } from "../../shared/args.js";
 
-export const OpenArgsSchema = z.object({
-  env: z.string().optional(),
-  studio: z.boolean().default(false),
-  projectSlug: z.string().optional(),
-});
+export const getOpenArgsSchema = defineSchema((v) =>
+  v.object({
+    env: v.string().optional(),
+    studio: v.boolean().default(false),
+    projectSlug: v.string().optional(),
+  })
+);
+
+export const OpenArgsSchema = getOpenArgsSchema();
 
-export type OpenOptions = z.infer<typeof OpenArgsSchema>;
+export type OpenOptions = InferSchema<ReturnType<typeof getOpenArgsSchema>>;
 
 export const parseOpenArgs = createArgParser(OpenArgsSchema, {
   env: { keys: ["env"], type: "string" },

package/src/cli/commands/pull/command.ts

@@ -7,7 +7,8 @@
  * @module cli/commands/pull
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import { dirname, join, normalize, resolve } from "../../../src/platform/compat/path/index.js";
 import { cliLogger } from "../../utils/index.js";
 import { cwd } from "../../../src/platform/index.js";
@@ -25,21 +26,25 @@ import { withSpan } from "../../../src/observability/tracing/otlp-setup.js";
 import { CommonArgs, createArgParser } from "../../shared/args.js";
 
 /**
- * Zod schema for pull command arguments
+ * Schema factory for pull command arguments
  */
-export const PullArgsSchema = z.object({
-  projectSlug: z.string().optional(),
-  projects: z.array(z.string()).optional(),
-  projectDir: z.string().optional(),
-  branch: z.string().optional(),
-  env: z.string().optional(),
-  release: z.string().optional(),
-  force: z.boolean().default(false),
-  dryRun: z.boolean().default(false),
-  quiet: z.boolean().default(false),
-});
-
-export type PullArgs = z.infer<typeof PullArgsSchema>;
+export const getPullArgsSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().optional(),
+    projects: v.array(v.string()).optional(),
+    projectDir: v.string().optional(),
+    branch: v.string().optional(),
+    env: v.string().optional(),
+    release: v.string().optional(),
+    force: v.boolean().default(false),
+    dryRun: v.boolean().default(false),
+    quiet: v.boolean().default(false),
+  })
+);
+
+export const PullArgsSchema = getPullArgsSchema();
+
+export type PullArgs = InferSchema<ReturnType<typeof getPullArgsSchema>>;
 
 /**
  * Parse pull command arguments from CLI args

package/src/cli/commands/push/command.ts

@@ -7,7 +7,8 @@
  * @module cli/commands/push
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import { join, relative } from "../../../src/platform/compat/path/index.js";
 import { cliLogger } from "../../utils/index.js";
 import { cwd } from "../../../src/platform/index.js";
@@ -28,18 +29,22 @@ import { listAllFiles } from "../pull/index.js";
 import { CommonArgs, createArgParser } from "../../shared/args.js";
 
 /**
- * Zod schema for push command arguments
+ * Schema factory for push command arguments
  */
-export const PushArgsSchema = z.object({
-  projectSlug: z.string().optional(),
-  projectDir: z.string().optional(),
-  branch: z.string().optional(),
-  force: z.boolean().default(false),
-  dryRun: z.boolean().default(false),
-  quiet: z.boolean().default(false),
-});
-
-export type PushArgs = z.infer<typeof PushArgsSchema>;
+export const getPushArgsSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().optional(),
+    projectDir: v.string().optional(),
+    branch: v.string().optional(),
+    force: v.boolean().default(false),
+    dryRun: v.boolean().default(false),
+    quiet: v.boolean().default(false),
+  })
+);
+
+export const PushArgsSchema = getPushArgsSchema();
+
+export type PushArgs = InferSchema<ReturnType<typeof getPushArgsSchema>>;
 
 /**
  * Parse push command arguments from CLI args

package/src/cli/commands/routes/handler.ts

@@ -2,17 +2,21 @@
  * Routes command handler
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
 import { cwd } from "../../../src/platform/index.js";
 import { routesCommand } from "./command.js";
 import { showLogo } from "../../utils/index.js";
 import { CommonArgs, createArgParser, parseArgsOrThrow } from "../../shared/args.js";
 import type { ParsedArgs } from "../../shared/types.js";
 
-const RoutesArgsSchema = z.object({
-  projectDir: z.string().default(""),
-  json: z.boolean().default(false),
-});
+const getRoutesArgsSchema = defineSchema((v) =>
+  v.object({
+    projectDir: v.string().default(""),
+    json: v.boolean().default(false),
+  })
+);
+
+const RoutesArgsSchema = getRoutesArgsSchema();
 
 export const parseRoutesArgs = createArgParser(RoutesArgsSchema, {
   projectDir: CommonArgs.projectDir,

package/src/cli/commands/schema/handler.ts

@@ -1,13 +1,17 @@
 import * as dntShim from "../../../_dnt.shims.js";
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
 import { createArgParser, parseArgsOrThrow } from "../../shared/args.js";
 import type { ParsedArgs } from "../../shared/types.js";
 import type { CommandCategory } from "../../help/types.js";
 import { generateCommandSchema, generateSchema } from "./command.js";
 
-const SchemaArgsSchema = z.object({
-  category: z.string().optional(),
-});
+const getSchemaArgsSchema = defineSchema((v) =>
+  v.object({
+    category: v.string().optional(),
+  })
+);
+
+const SchemaArgsSchema = getSchemaArgsSchema();
 
 const parseSchemaArgs = createArgParser(SchemaArgsSchema, {
   category: { keys: ["category", "c"], type: "string" },

package/src/cli/commands/serve/handler.ts

@@ -1,19 +1,23 @@
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
 import { DEFAULT_DEV_SERVER_PORT } from "../../utils/index.js";
 import { serveCommand } from "./command.js";
 import { ServerModeSchema } from "../../shared/types.js";
 import { createArgParser, parseArgsOrThrow } from "../../shared/args.js";
 import type { ParsedArgs } from "../../shared/types.js";
 
-const ServeArgsSchema = z.object({
-  mode: ServerModeSchema.default("production"),
-  port: z.number().default(DEFAULT_DEV_SERVER_PORT),
-  hostname: z.string().default("0.0.0.0"),
-  split: z.boolean().default(false),
-  binary: z.boolean().default(false),
-  binaryPath: z.string().default("./bin/veryfront"),
-  debug: z.boolean().default(false),
-});
+const getServeArgsSchema = defineSchema((v) =>
+  v.object({
+    mode: ServerModeSchema.default("production"),
+    port: v.number().default(DEFAULT_DEV_SERVER_PORT),
+    hostname: v.string().default("0.0.0.0"),
+    split: v.boolean().default(false),
+    binary: v.boolean().default(false),
+    binaryPath: v.string().default("./bin/veryfront"),
+    debug: v.boolean().default(false),
+  })
+);
+
+const ServeArgsSchema = getServeArgsSchema();
 
 export const parseServeArgs = createArgParser(ServeArgsSchema, {
   mode: { keys: ["mode", "m"], type: "string" },
@@ -28,7 +32,7 @@ export const parseServeArgs = createArgParser(ServeArgsSchema, {
 export async function handleServeCommand(args: ParsedArgs): Promise<void> {
   const opts = parseArgsOrThrow(parseServeArgs, "serve", args);
   await serveCommand({
-    mode: opts.mode,
+    mode: opts.mode as "production" | "proxy" | "combined",
     port: opts.port,
     bindAddress: opts.hostname,
     splitMode: opts.split,

package/src/cli/commands/start/handler.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
 import { startCommand } from "./command.js";
 import { createArgParser, parseArgsOrThrow } from "../../shared/args.js";
 import type { ParsedArgs } from "../../shared/types.js";
@@ -6,12 +6,16 @@ import { DEFAULT_MCP_PORT } from "../../shared/constants.js";
 
 const DEFAULT_START_PORT = 8080;
 
-const StartArgsSchema = z.object({
-  port: z.number().default(DEFAULT_START_PORT),
-  mcpPort: z.number().default(DEFAULT_MCP_PORT),
-  project: z.string().optional(),
-  headless: z.boolean().default(false),
-});
+const getStartArgsSchema = defineSchema((v) =>
+  v.object({
+    port: v.number().default(DEFAULT_START_PORT),
+    mcpPort: v.number().default(DEFAULT_MCP_PORT),
+    project: v.string().optional(),
+    headless: v.boolean().default(false),
+  })
+);
+
+const StartArgsSchema = getStartArgsSchema();
 
 export const parseStartArgs = createArgParser(StartArgsSchema, {
   port: { keys: ["port", "p"], type: "number" },

package/src/cli/commands/studio/handler.ts

@@ -2,16 +2,20 @@
  * Studio command handler
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
 import { createArgParser, parseArgsOrThrow } from "../../shared/args.js";
 import type { ParsedArgs } from "../../shared/types.js";
 import { studioCommand } from "./index.js";
 
-const StudioArgsSchema = z.object({
-  project: z.string().optional(),
-  branch: z.string().optional(),
-  file: z.string().optional(),
-});
+const getStudioArgsSchema = defineSchema((v) =>
+  v.object({
+    project: v.string().optional(),
+    branch: v.string().optional(),
+    file: v.string().optional(),
+  })
+);
+
+const StudioArgsSchema = getStudioArgsSchema();
 
 export const parseStudioArgs = createArgParser(StudioArgsSchema, {
   project: { keys: ["project"], type: "string", positional: 0 },

package/src/cli/commands/styles/command.ts

@@ -1,5 +1,6 @@
 import * as dntShim from "../../../_dnt.shims.js";
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import { getConfig } from "../../../src/config/index.js";
 import {
   enhanceAdapterWithFS,
@@ -17,23 +18,27 @@ import { cliLogger, exitProcess } from "../../utils/index.js";
 import type { StylesArgs } from "./handler.js";
 import { writeJobResultIfConfigured } from "../../utils/write-job-result.js";
 
-const StyleArtifactBuildConfigSchema = z.object({
-  style_profile_hash: z.string().min(1).optional(),
-  branch: z.string().min(1).optional(),
-  environment_name: z.string().min(1).optional(),
-  release_id: z.string().min(1).optional(),
-}).superRefine((value, ctx) => {
-  const selectorCount = [value.branch, value.environment_name, value.release_id].filter(Boolean)
-    .length;
-  if (selectorCount !== 1) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "Exactly one of branch, environment_name, or release_id is required.",
-    });
-  }
-});
+const getStyleArtifactBuildConfigSchema = defineSchema((v) =>
+  v.object({
+    style_profile_hash: v.string().min(1).optional(),
+    branch: v.string().min(1).optional(),
+    environment_name: v.string().min(1).optional(),
+    release_id: v.string().min(1).optional(),
+  }).superRefine((value, ctx) => {
+    const selectorCount = [value.branch, value.environment_name, value.release_id].filter(Boolean)
+      .length;
+    if (selectorCount !== 1) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Exactly one of branch, environment_name, or release_id is required.",
+      });
+    }
+  })
+);
+
+const StyleArtifactBuildConfigSchema = getStyleArtifactBuildConfigSchema();
 
-type StyleArtifactBuildConfig = z.infer<typeof StyleArtifactBuildConfigSchema>;
+type StyleArtifactBuildConfig = InferSchema<ReturnType<typeof getStyleArtifactBuildConfigSchema>>;
 
 interface StyleBuildContentContext {
   branch?: string;

package/src/cli/commands/styles/handler.ts

@@ -1,14 +1,19 @@
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import { createArgParser, parseArgsOrThrow } from "../../shared/args.js";
 import type { ParsedArgs } from "../../shared/types.js";
 
-const StylesArgsSchema = z.object({
-  subcommand: z.literal("build-artifact"),
-  config: z.string().optional(),
-  debug: z.boolean().default(false),
-});
+const getStylesArgsSchema = defineSchema((v) =>
+  v.object({
+    subcommand: v.literal("build-artifact"),
+    config: v.string().optional(),
+    debug: v.boolean().default(false),
+  })
+);
+
+const StylesArgsSchema = getStylesArgsSchema();
 
-export type StylesArgs = z.infer<typeof StylesArgsSchema>;
+export type StylesArgs = InferSchema<ReturnType<typeof getStylesArgsSchema>>;
 
 export const parseStylesArgs = createArgParser(StylesArgsSchema, {
   subcommand: { keys: ["subcommand"], type: "string", positional: 0 },

package/src/cli/commands/task/handler.ts

@@ -1,14 +1,19 @@
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import { createArgParser, parseArgsOrThrow } from "../../shared/args.js";
 import type { ParsedArgs } from "../../shared/types.js";
 
-const TaskArgsSchema = z.object({
-  name: z.string(),
-  config: z.string().optional(),
-  debug: z.boolean().default(false),
-});
+const getTaskArgsSchema = defineSchema((v) =>
+  v.object({
+    name: v.string(),
+    config: v.string().optional(),
+    debug: v.boolean().default(false),
+  })
+);
+
+const TaskArgsSchema = getTaskArgsSchema();
 
-export type TaskArgs = z.infer<typeof TaskArgsSchema>;
+export type TaskArgs = InferSchema<ReturnType<typeof getTaskArgsSchema>>;
 
 export const parseTaskArgs = createArgParser(TaskArgsSchema, {
   name: { keys: ["name"], type: "string", positional: 0 },

package/src/cli/commands/test/handler.ts

@@ -1,5 +1,5 @@
 import * as dntShim from "../../../_dnt.shims.js";
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
 import { createArgParser, parseArgsOrThrow } from "../../shared/args.js";
 import type { ParsedArgs } from "../../shared/types.js";
 import {
@@ -10,10 +10,14 @@ import {
 } from "../../shared/json-output.js";
 import { parseTestOutput } from "./command.js";
 
-const TestArgsSchema = z.object({
-  filter: z.string().optional(),
-  parallel: z.boolean().default(false),
-});
+const getTestArgsSchema = defineSchema((v) =>
+  v.object({
+    filter: v.string().optional(),
+    parallel: v.boolean().default(false),
+  })
+);
+
+const TestArgsSchema = getTestArgsSchema();
 
 const parseTestArgs = createArgParser(TestArgsSchema, {
   filter: { keys: ["filter"], type: "string", positional: 0 },

package/src/cli/commands/up/command.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import { cliLogger } from "../../utils/index.js";
 import { cwd } from "../../../src/platform/index.js";
 import { join } from "../../../src/platform/compat/path/index.js";
@@ -13,12 +14,16 @@ import { readConfigFile, type VeryfrontConfig } from "../../shared/config.js";
 import { pushCommand } from "../push/index.js";
 import { deployCommand } from "../deploy/index.js";
 
-export const UpArgsSchema = z.object({
-  force: z.boolean().default(false),
-  dryRun: z.boolean().default(false),
-});
+export const getUpArgsSchema = defineSchema((v) =>
+  v.object({
+    force: v.boolean().default(false),
+    dryRun: v.boolean().default(false),
+  })
+);
+
+export const UpArgsSchema = getUpArgsSchema();
 
-export type UpOptions = z.infer<typeof UpArgsSchema>;
+export type UpOptions = InferSchema<ReturnType<typeof getUpArgsSchema>>;
 
 export const parseUpArgs = createArgParser(UpArgsSchema, {
   force: CommonArgs.force,

package/src/cli/commands/uploads/command.ts

@@ -1,6 +1,10 @@
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 
-type SafeParseResult<T> = { success: true; data: T } | { success: false; error: z.ZodError };
+type SafeParseResult<T> = { success: true; data: T } | {
+  success: false;
+  error: Error & { issues: unknown[] };
+};
 import { createFileSystem, cwd, lookupMimeType } from "../../../src/platform/index.js";
 import { dirname, join, normalize, resolve } from "../../../src/platform/compat/path/index.js";
 import { withSpan } from "../../../src/observability/tracing/otlp-setup.js";
@@ -41,52 +45,68 @@ interface CreateUploadResponse {
   required_headers: Record<string, string>;
 }
 
-const UploadListArgsSchema = z.object({
-  projectSlug: z.string().optional(),
-  projectDir: z.string().optional(),
-  path: z.string().optional(),
-  limit: z.coerce.number().min(1).max(100).optional(),
-  recursive: z.boolean().default(true),
-  json: z.boolean().default(false),
-  quiet: z.boolean().default(false),
-});
-
-export type UploadListOptions = z.infer<typeof UploadListArgsSchema>;
-
-const UploadPullArgsSchema = z.object({
-  projectSlug: z.string().optional(),
-  projectDir: z.string().optional(),
-  uploads: z.array(z.string()).default([]),
-  path: z.string().optional(),
-  all: z.boolean().default(false),
-  outputDir: z.string().default(join(cwd(), "uploads")),
-  json: z.boolean().default(false),
-  quiet: z.boolean().default(false),
-});
-
-export type UploadPullOptions = z.infer<typeof UploadPullArgsSchema>;
-
-const UploadPutArgsSchema = z.object({
-  projectSlug: z.string().optional(),
-  projectDir: z.string().optional(),
-  uploadPath: z.string().min(1),
-  from: z.string().min(1),
-  contentType: z.string().optional(),
-  json: z.boolean().default(false),
-  quiet: z.boolean().default(false),
-});
-
-export type UploadPutOptions = z.infer<typeof UploadPutArgsSchema>;
-
-const UploadDeleteArgsSchema = z.object({
-  projectSlug: z.string().optional(),
-  projectDir: z.string().optional(),
-  uploadPath: z.string().min(1),
-  json: z.boolean().default(false),
-  quiet: z.boolean().default(false),
-});
-
-export type UploadDeleteOptions = z.infer<typeof UploadDeleteArgsSchema>;
+const getUploadListArgsSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().optional(),
+    projectDir: v.string().optional(),
+    path: v.string().optional(),
+    limit: v.coerce.number().min(1).max(100).optional(),
+    recursive: v.boolean().default(true),
+    json: v.boolean().default(false),
+    quiet: v.boolean().default(false),
+  })
+);
+
+const UploadListArgsSchema = getUploadListArgsSchema();
+
+export type UploadListOptions = InferSchema<ReturnType<typeof getUploadListArgsSchema>>;
+
+const getUploadPullArgsSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().optional(),
+    projectDir: v.string().optional(),
+    uploads: v.array(v.string()).default([]),
+    path: v.string().optional(),
+    all: v.boolean().default(false),
+    outputDir: v.string().default(join(cwd(), "uploads")),
+    json: v.boolean().default(false),
+    quiet: v.boolean().default(false),
+  })
+);
+
+const UploadPullArgsSchema = getUploadPullArgsSchema();
+
+export type UploadPullOptions = InferSchema<ReturnType<typeof getUploadPullArgsSchema>>;
+
+const getUploadPutArgsSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().optional(),
+    projectDir: v.string().optional(),
+    uploadPath: v.string().min(1),
+    from: v.string().min(1),
+    contentType: v.string().optional(),
+    json: v.boolean().default(false),
+    quiet: v.boolean().default(false),
+  })
+);
+
+const UploadPutArgsSchema = getUploadPutArgsSchema();
+
+export type UploadPutOptions = InferSchema<ReturnType<typeof getUploadPutArgsSchema>>;
+
+const getUploadDeleteArgsSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().optional(),
+    projectDir: v.string().optional(),
+    uploadPath: v.string().min(1),
+    json: v.boolean().default(false),
+    quiet: v.boolean().default(false),
+  })
+);
+
+const UploadDeleteArgsSchema = getUploadDeleteArgsSchema();
+
+export type UploadDeleteOptions = InferSchema<ReturnType<typeof getUploadDeleteArgsSchema>>;
 
 function getBooleanArg(args: ParsedArgs, ...keys: string[]): boolean {
   return keys.some((key) => Boolean(args[key]));
@@ -140,7 +160,7 @@ export function parseUploadsListArgs(
     recursive: args.recursive === undefined ? true : Boolean(args.recursive),
     json: getBooleanArg(args, "json", "j"),
     quiet: getBooleanArg(args, "quiet", "q"),
-  });
+  }) as SafeParseResult<UploadListOptions>;
 }
 
 export function parseUploadsPullArgs(
@@ -155,7 +175,7 @@ export function parseUploadsPullArgs(
     outputDir: getStringArg(args, "output-dir") ?? join(cwd(), "uploads"),
     json: getBooleanArg(args, "json", "j"),
     quiet: getBooleanArg(args, "quiet", "q"),
-  });
+  }) as SafeParseResult<UploadPullOptions>;
 }
 
 export function parseUploadsPutArgs(
@@ -169,7 +189,7 @@ export function parseUploadsPutArgs(
     contentType: getStringArg(args, "content-type"),
     json: getBooleanArg(args, "json", "j"),
     quiet: getBooleanArg(args, "quiet", "q"),
-  });
+  }) as SafeParseResult<UploadPutOptions>;
 }
 
 export function parseUploadsDeleteArgs(
@@ -181,7 +201,7 @@ export function parseUploadsDeleteArgs(
     uploadPath: typeof args._[2] === "string" ? args._[2] : "",
     json: getBooleanArg(args, "json", "j"),
     quiet: getBooleanArg(args, "quiet", "q"),
-  });
+  }) as SafeParseResult<UploadDeleteOptions>;
 }
 
 export function buildUploadsListUrl(projectSlug: string): string {