transloadit 4.14.0 → 5.0.0

package/src/alphalib/types/robots/image-optimize.ts

@@ -1,47 +1,32 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import {
-  interpolateRobot,
+  createProcessingExample,
+  defineRobot,
   optimize_priority,
   robotBase,
+  robotImageProcessingMeta,
   robotUse,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
-  example_code: {
-    steps: {
-      optimized: {
-        robot: '/image/optimize',
-        use: ':original',
-      },
-    },
-  },
+  ...robotImageProcessingMeta,
+  example_code: createProcessingExample('optimized', '/image/optimize'),
   example_code_description: 'Optimize uploaded images:',
-  minimum_charge: 0,
-  output_factor: 0.6,
-  override_lvl1: 'Image Manipulation',
   purpose_sentence: 'reduces the size of images while maintaining the same visual quality',
   purpose_verb: 'optimize',
   purpose_word: 'optimize',
   purpose_words: 'Optimize images without quality loss',
-  service_slug: 'image-manipulation',
-  slot_count: 5,
   title: 'Optimize images without quality loss',
-  typical_file_size_mb: 0.8,
-  typical_file_type: 'image',
   name: 'ImageOptimizeRobot',
-  priceFactor: 1,
   queueSlotCount: 5,
-  isAllowedForUrlTransform: true,
   trackOutputFileSize: true,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const robotImageOptimizeInstructionsSchema = robotBase
@@ -60,7 +45,7 @@ It works well together with [🤖/image/resize](/docs/robots/image-resize/) to b
 > [!Note]
 > PNG optimization uses only lossless (optipng) compressors by default. To also enable lossy compression (pngquant), set \`lossy: true\`. When enabled, both lossy and lossless compressors compete and the smallest result wins, which may cause color shifts in some images.
 `),
-    priority: optimize_priority.describe(`
+    priority: optimize_priority.default('compression-ratio').describe(`
 Provides different algorithms for better or worse compression for your images, but that run slower or faster. The value \`"conversion-speed"\` will result in an average compression ratio of 18%. \`"compression-ratio"\` will result in an average compression ratio of 31%.
 `),
     progressive: z
@@ -95,34 +80,23 @@ When set to \`true\`, both lossy and lossless PNG optimizers compete and the sma
   })
   .strict()
 
-export const robotImageOptimizeInstructionsWithHiddenFieldsSchema =
-  robotImageOptimizeInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotImageOptimizeInstructionsSchema.shape.result])
-      .optional(),
-  })
-
-export type RobotImageOptimizeInstructions = z.infer<typeof robotImageOptimizeInstructionsSchema>
-export type RobotImageOptimizeInstructionsWithHiddenFields = z.infer<
-  typeof robotImageOptimizeInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotImageOptimizeInstructionsSchema.shape> =
+  defineRobot(meta, robotImageOptimizeInstructionsSchema)
 
-export const interpolatableRobotImageOptimizeInstructionsSchema = interpolateRobot(
-  robotImageOptimizeInstructionsSchema,
-)
-export type InterpolatableRobotImageOptimizeInstructions =
-  InterpolatableRobotImageOptimizeInstructionsInput
+export const {
+  withHiddenFields: robotImageOptimizeInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotImageOptimizeInstructionsSchema,
+  interpolatableWithHiddenFields:
+    interpolatableRobotImageOptimizeInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotImageOptimizeInstructionsInput = z.input<
-  typeof interpolatableRobotImageOptimizeInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotImageOptimizeInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotImageOptimizeInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotImageOptimizeInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotImageOptimizeInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotImageOptimizeInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotImageOptimizeInstructionsWithHiddenFieldsSchema
->
+export type RobotImageOptimizeInstructions = Instructions['output']
+export type RobotImageOptimizeInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotImageOptimizeInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotImageOptimizeInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotImageOptimizeInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotImageOptimizeInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

package/src/alphalib/types/robots/image-resize.ts

@@ -1,20 +1,28 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinitionWithHiddenFields,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import { imagemagickDensityPattern } from '../../imagemagickDensity.ts'
+import { zodInputPreservingTransform } from '../../lib/zodInputSemantics.ts'
 import {
   color_without_alpha_with_named,
   colorspaceSchema,
   complexHeightSchema,
   complexWidthSchema,
+  createProcessingExample,
+  defineRobotWithHiddenFields,
   httpUrlSchema,
+  imageAdaptiveFilteringSchema,
   imageQualitySchema,
-  interpolateRobot,
   percentageSchema,
   positionSchema,
   robotBase,
   robotImagemagick,
+  robotImageProcessingMeta,
   robotUse,
   unsafeCoordinatesSchema,
 } from './_instructions-primitives.ts'
@@ -22,42 +30,22 @@ import {
 const imageResizeGravitySchema = z.union([positionSchema, z.enum(['attention', 'entropy'])])
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
-  example_code: {
-    steps: {
-      resized: {
-        robot: '/image/resize',
-        use: ':original',
-        width: 200,
-      },
-    },
-  },
+  ...robotImageProcessingMeta,
+  example_code: createProcessingExample('resized', '/image/resize', {
+    width: 200,
+  }),
   example_code_description:
     'Resize uploaded images to a width of 200px while keeping their original aspect ratio:',
-  minimum_charge: 0,
-  output_factor: 0.6,
-  override_lvl1: 'Image Manipulation',
   purpose_sentence:
     'resizes, crops, changes colorization, rotation, and applies text and watermarks to images',
   purpose_verb: 'convert',
   purpose_word: 'convert/resize/watermark',
   purpose_words: 'Convert, resize, or watermark images',
-  service_slug: 'image-manipulation',
-  slot_count: 5,
   title: 'Convert, resize, or watermark images',
-  typical_file_size_mb: 0.8,
-  typical_file_type: 'image',
   uses_tools: ['imagemagick'],
   name: 'ImageResizeRobot',
-  priceFactor: 1,
   queueSlotCount: 5,
-  isAllowedForUrlTransform: true,
   trackOutputFileSize: true,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const oneTextSchema = z.object({
@@ -310,12 +298,7 @@ To preserve animations, GIF files are not flattened when this is set to \`true\`
 Prevents gamma errors [common in many image scaling algorithms](https://www.4p8.com/eric.brasseur/gamma.html).
 `),
     quality: imageQualitySchema,
-    adaptive_filtering: z
-      .boolean()
-      .default(false)
-      .describe(`
-Controls the image compression for PNG images. Setting to \`true\` results in smaller file size, while increasing processing time. It is encouraged to keep this option disabled.
-`),
+    adaptive_filtering: imageAdaptiveFilteringSchema,
     background: color_without_alpha_with_named.default('#FFFFFF').describe(`
 Either the hexadecimal code or [name](https://www.imagemagick.org/script/color.php#color_names) of the color used to fill the background (used for the \`pad\` resize strategy).
 
@@ -380,7 +363,7 @@ Please also take a look at [🤖/image/optimize](/docs/robots/image-optimize/).
 `),
     blur: z
       .string()
-      .regex(/^\d+(\.\d+)?x\d+(\.\d+)?$/)
+      .regex(/^[0-9]+(\.[0-9]+)?x[0-9]+(\.[0-9]+)?$/u)
       .nullable()
       .default(null)
       .describe(`
@@ -526,7 +509,7 @@ This is useful for creating tiled watermark patterns that cover the full image.
 Interlaces the image if set to \`true\`, which makes the image load progressively in browsers. Instead of rendering the image from top to bottom, the browser will first show a low-res blurry version of the images which is then quickly replaced with the actual image as the data arrives. This greatly increases the user experience, but comes at a cost of a file size increase by around 10%.
 `),
     transparent: z
-      .union([color_without_alpha_with_named, z.string().regex(/^\d+,\d+,\d+$/)])
+      .union([color_without_alpha_with_named, z.string().regex(/^[0-9]+,[0-9]+,[0-9]+$/u)])
       .optional()
       .describe(`
 Make this color transparent within the image. Example: \`"255,255,255"\`.
@@ -606,8 +589,8 @@ Transform the image to black and white. This is a shortcut for setting the color
 `),
     shave: z
       .union([
-        z.string().regex(/^\d+(x\d+)?$/),
-        z.number().int().min(0).transform(String), // Accept numbers and convert to string
+        z.string().regex(/^[0-9]+(x[0-9]+)?$/u),
+        zodInputPreservingTransform(z.number().int().min(0), String),
       ])
       .optional()
       .describe(`
@@ -616,75 +599,68 @@ Shave pixels from the image edges. The value should be in the format \`width\` o
   })
   .strict()
 
-export const robotImageResizeInstructionsWithHiddenFieldsSchema =
-  robotImageResizeInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotImageResizeInstructionsSchema.shape.result])
-      .optional(),
-    stack: z.string().optional().describe('Legacy parameter, use imagemagick_stack instead'),
-    text: z
-      .union([
-        // Support single text object (backward compatibility)
+const hiddenFields = {
+  stack: z.string().optional().describe('Legacy parameter, use imagemagick_stack instead'),
+  text: z
+    .union([
+      // Support single text object (backward compatibility)
+      oneTextSchema.extend({
+        gravity: positionSchema
+          .default('top-left')
+          .optional()
+          .describe(`
+            Legacy. The direction from which to start the offsets.
+            `),
+      }),
+      // Support array of text objects (current schema)
+      z.array(
         oneTextSchema.extend({
           gravity: positionSchema
             .default('top-left')
             .optional()
             .describe(`
-            Legacy. The direction from which to start the offsets.
-            `),
-        }),
-        // Support array of text objects (current schema)
-        z.array(
-          oneTextSchema.extend({
-            gravity: positionSchema
-              .default('top-left')
-              .optional()
-              .describe(`
               Legacy. The direction from which to start the offsets.
               `),
-          }),
-        ),
-      ])
-      .optional()
-      .describe(TEXT_DESCRIPTION),
-    watermark_position_x: z
-      .number()
-      .int()
-      .optional()
-      .describe(`
+        }),
+      ),
+    ])
+    .optional()
+    .describe(TEXT_DESCRIPTION),
+  watermark_position_x: z
+    .number()
+    .int()
+    .optional()
+    .describe(`
       Legacy alias for \`watermark_x_offset\`. The x-offset in number of pixels at which the watermark will be placed.
       `),
-    watermark_position_y: z
-      .number()
-      .int()
-      .optional()
-      .describe(`
+  watermark_position_y: z
+    .number()
+    .int()
+    .optional()
+    .describe(`
       Legacy alias for \`watermark_y_offset\`. The y-offset in number of pixels at which the watermark will be placed.
       `),
-  })
+}
 
-export type RobotImageResizeInstructions = z.infer<typeof robotImageResizeInstructionsSchema>
-export type RobotImageResizeInstructionsInput = z.input<typeof robotImageResizeInstructionsSchema>
-export type RobotImageResizeInstructionsWithHiddenFields = z.infer<
-  typeof robotImageResizeInstructionsWithHiddenFieldsSchema
->
-
-export const interpolatableRobotImageResizeInstructionsSchema = interpolateRobot(
-  robotImageResizeInstructionsSchema,
-)
-export type InterpolatableRobotImageResizeInstructions =
-  InterpolatableRobotImageResizeInstructionsInput
-
-export type InterpolatableRobotImageResizeInstructionsInput = z.input<
-  typeof interpolatableRobotImageResizeInstructionsSchema
->
-
-export const interpolatableRobotImageResizeInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotImageResizeInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotImageResizeInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotImageResizeInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotImageResizeInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotImageResizeInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinitionWithHiddenFields<
+  typeof robotImageResizeInstructionsSchema.shape,
+  typeof hiddenFields
+> = defineRobotWithHiddenFields(meta, robotImageResizeInstructionsSchema, hiddenFields)
+
+export const {
+  withHiddenFields: robotImageResizeInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotImageResizeInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotImageResizeInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
+
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
+
+export type RobotImageResizeInstructions = Instructions['output']
+export type RobotImageResizeInstructionsInput = Instructions['input']
+export type RobotImageResizeInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotImageResizeInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotImageResizeInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotImageResizeInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotImageResizeInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

package/src/alphalib/types/robots/image-upscale.ts

@@ -1,99 +1,87 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinitionWithHiddenFields,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
+import { imageUpscaleDefaultModelIdentifier, imageUpscaleModelIdentifiers } from './_ai-models.ts'
 import {
   autoProviderDescription,
-  interpolateRobot,
+  createProcessingExample,
+  defineRobotWithHiddenFields,
+  robotArtificialIntelligenceMeta,
   robotBase,
   robotUse,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
-  example_code: {
-    steps: {
-      upscaled: {
-        robot: '/image/upscale',
-        use: ':original',
-        scale: 2,
-        face_enhance: true,
-      },
-    },
-  },
+  ...robotArtificialIntelligenceMeta,
+  example_code: createProcessingExample('upscaled', '/image/upscale', {
+    scale: 2,
+    face_enhance: true,
+  }),
   example_code_description: 'Upscale uploaded images and enhance faces:',
-  minimum_charge: 0,
-  output_factor: 0.6,
   purpose_sentence: 'upscales images using AI',
   purpose_verb: 'generate',
   purpose_word: 'upscale',
   purpose_words: 'Upscale images',
-  service_slug: 'artificial-intelligence',
-  slot_count: 10,
   title: 'Upscale images',
-  typical_file_size_mb: 1.2,
-  typical_file_type: 'image',
   name: 'ImageUpscaleRobot',
-  priceFactor: 1,
-  queueSlotCount: 10,
   minimumChargeUsd: 0.06,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: true,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
   stage: 'beta',
 }
 
+const upscaleModelSchema = z
+  .enum(imageUpscaleModelIdentifiers)
+  .default(imageUpscaleDefaultModelIdentifier)
+const upscaleScaleSchema = z.union([z.literal(2), z.literal(4)]).default(2)
+const upscaleFaceEnhanceSchema = z.boolean().default(false)
+
 export const robotImageUpscaleInstructionsSchema = robotBase
   .merge(robotUse)
   .extend({
     robot: z.literal('/image/upscale'),
-    model: z
-      .enum(['nightmareai/real-esrgan', 'tencentarc/gfpgan', 'sczhou/codeformer'])
+    // Outer optional preserves parsed input; normalization applies the published inner defaults.
+    model: upscaleModelSchema
       .optional()
-      .describe('The AI model to use for image upscaling. Defaults to nightmareai/real-esrgan.'),
-    scale: z
-      .union([z.literal(2), z.literal(4)])
+      .describe(
+        `The AI model to use for image upscaling. Defaults to ${upscaleModelSchema.parse(undefined)}.`,
+      ),
+    scale: upscaleScaleSchema
       .optional()
-      .describe('Upscale factor. Defaults to 2.'),
-    face_enhance: z
-      .boolean()
+      .describe(`Upscale factor. Defaults to ${upscaleScaleSchema.parse(undefined)}.`),
+    face_enhance: upscaleFaceEnhanceSchema
       .optional()
-      .describe('Enable face enhancement for better face restoration. Defaults to false.'),
+      .describe(
+        `Enable face enhancement for better face restoration. Defaults to ${upscaleFaceEnhanceSchema.parse(undefined)}.`,
+      ),
   })
   .strict()
 
-export const robotImageUpscaleInstructionsWithHiddenFieldsSchema =
-  robotImageUpscaleInstructionsSchema.extend({
-    provider: z.string().default('auto').describe(autoProviderDescription),
-    result: z
-      .union([z.literal('debug'), robotImageUpscaleInstructionsSchema.shape.result])
-      .optional(),
-  })
+const hiddenFields = {
+  provider: z.string().default('auto').describe(autoProviderDescription),
+}
 
-export type RobotImageUpscaleInstructions = z.infer<typeof robotImageUpscaleInstructionsSchema>
-export type RobotImageUpscaleInstructionsWithHiddenFields = z.infer<
-  typeof robotImageUpscaleInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinitionWithHiddenFields<
+  typeof robotImageUpscaleInstructionsSchema.shape,
+  typeof hiddenFields
+> = defineRobotWithHiddenFields(meta, robotImageUpscaleInstructionsSchema, hiddenFields)
 
-export const interpolatableRobotImageUpscaleInstructionsSchema = interpolateRobot(
-  robotImageUpscaleInstructionsSchema,
-)
-export type InterpolatableRobotImageUpscaleInstructions =
-  InterpolatableRobotImageUpscaleInstructionsInput
+export const {
+  withHiddenFields: robotImageUpscaleInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotImageUpscaleInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotImageUpscaleInstructionsInput = z.input<
-  typeof interpolatableRobotImageUpscaleInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotImageUpscaleInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotImageUpscaleInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotImageUpscaleInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema
->
+export type RobotImageUpscaleInstructions = Instructions['output']
+export type RobotImageUpscaleInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotImageUpscaleInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotImageUpscaleInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotImageUpscaleInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotImageUpscaleInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']