@transloadit/zod 4.3.4 → 4.4.0

package/dist/v4/robots/image-facedetect.js

@@ -1,5 +1,5 @@
 import { z } from 'zod/v4';
-import { aiProviderSchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { autoProviderDescription, awsGcpAiProviderSchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const imageFacedetectFaceSelectionModes = [
     'each',
     'group',
@@ -74,10 +74,10 @@ This <dfn>Robot</dfn> works well together with [🤖/image/resize](/docs/robots/
 
 </div>
 `),
-    provider: aiProviderSchema.optional().describe(`
-Which AI provider to leverage.
+    provider: awsGcpAiProviderSchema.describe(`
+${autoProviderDescription}
 
-Transloadit outsources this task and abstracts the interface so you can expect the same data structures, but different latencies and information being returned. Different cloud vendors have different areas they shine in, and we recommend to try out and see what yields the best results for your use case.
+Set this to \`"aws"\` or \`"gcp"\` to force a specific provider.
 `),
     crop: z
         .boolean()

package/dist/v4/robots/image-generate.d.ts

@@ -99,7 +99,7 @@ export declare const robotImageGenerateInstructionsWithHiddenFieldsSchema: z.Zod
     width: z.ZodOptional<z.ZodNumber>;
     style: z.ZodOptional<z.ZodString>;
     num_outputs: z.ZodOptional<z.ZodNumber>;
-    provider: z.ZodOptional<z.ZodString>;
+    provider: z.ZodDefault<z.ZodString>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, z.core.$strict>;
 export type RobotImageGenerateInstructions = z.infer<typeof robotImageGenerateInstructionsSchema>;
@@ -152,7 +152,7 @@ export declare const interpolatableRobotImageGenerateInstructionsSchema: z.ZodOb
     width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     style: z.ZodOptional<z.ZodString>;
     num_outputs: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    provider: z.ZodOptional<z.ZodString>;
+    provider: z.ZodDefault<z.ZodString>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotImageGenerateInstructions = InterpolatableRobotImageGenerateInstructionsInput;
@@ -205,7 +205,7 @@ export declare const interpolatableRobotImageGenerateInstructionsWithHiddenField
     width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     style: z.ZodOptional<z.ZodString>;
     num_outputs: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    provider: z.ZodOptional<z.ZodString>;
+    provider: z.ZodDefault<z.ZodString>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotImageGenerateInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema>;

package/dist/v4/robots/image-generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-generate.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-generate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cA4ClB,CAAA;AASD,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsEtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}
+{"version":3,"file":"image-generate.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-generate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,IAAI,EAAE,cA4ClB,CAAA;AASD,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsEtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}

package/dist/v4/robots/image-generate.js

@@ -1,5 +1,5 @@
 import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { autoProviderDescription, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
     bytescount: 1,
     discount_factor: 1,
@@ -108,7 +108,7 @@ Best practice:
 })
     .strict();
 export const robotImageGenerateInstructionsWithHiddenFieldsSchema = robotImageGenerateInstructionsSchema.extend({
-    provider: z.string().optional().describe('Provider for generating the image.'),
+    provider: z.string().default('auto').describe(autoProviderDescription),
     result: z
         .union([z.literal('debug'), robotImageGenerateInstructionsSchema.shape.result])
         .optional(),

package/dist/v4/robots/image-merge.d.ts

@@ -42,11 +42,16 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     direction: z.ZodDefault<z.ZodEnum<{
         vertical: "vertical";
         horizontal: "horizontal";
+        grid: "grid";
     }>>;
     effect: z.ZodOptional<z.ZodEnum<{
         mosaic: "mosaic";
         "polaroid-stack": "polaroid-stack";
     }>>;
+    columns: z.ZodOptional<z.ZodNumber>;
+    rows: z.ZodOptional<z.ZodNumber>;
+    cell_width: z.ZodOptional<z.ZodNumber>;
+    cell_height: z.ZodOptional<z.ZodNumber>;
     border: z.ZodDefault<z.ZodNumber>;
     background: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
         none: "none";
@@ -67,6 +72,11 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     height: z.ZodOptional<z.ZodNumber>;
     seed: z.ZodOptional<z.ZodNumber>;
     shuffle: z.ZodDefault<z.ZodBoolean>;
+    sort_by: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        basename: "basename";
+        import_order: "import_order";
+    }>>;
     coverage: z.ZodOptional<z.ZodNumber>;
     adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
     quality: z.ZodDefault<z.ZodNumber>;
@@ -111,11 +121,16 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     direction: z.ZodDefault<z.ZodEnum<{
         vertical: "vertical";
         horizontal: "horizontal";
+        grid: "grid";
     }>>;
     effect: z.ZodOptional<z.ZodEnum<{
         mosaic: "mosaic";
         "polaroid-stack": "polaroid-stack";
     }>>;
+    columns: z.ZodOptional<z.ZodNumber>;
+    rows: z.ZodOptional<z.ZodNumber>;
+    cell_width: z.ZodOptional<z.ZodNumber>;
+    cell_height: z.ZodOptional<z.ZodNumber>;
     border: z.ZodDefault<z.ZodNumber>;
     background: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
         none: "none";
@@ -136,6 +151,11 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     height: z.ZodOptional<z.ZodNumber>;
     seed: z.ZodOptional<z.ZodNumber>;
     shuffle: z.ZodDefault<z.ZodBoolean>;
+    sort_by: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        basename: "basename";
+        import_order: "import_order";
+    }>>;
     coverage: z.ZodOptional<z.ZodNumber>;
     adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
     quality: z.ZodDefault<z.ZodNumber>;
@@ -184,11 +204,16 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         vertical: "vertical";
         horizontal: "horizontal";
+        grid: "grid";
     }>]>>;
     effect: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         mosaic: "mosaic";
         "polaroid-stack": "polaroid-stack";
     }>]>>;
+    columns: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    rows: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    cell_width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    cell_height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     border: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         none: "none";
@@ -209,6 +234,11 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     seed: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     shuffle: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    sort_by: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
+        basename: "basename";
+        import_order: "import_order";
+    }>]>>;
     coverage: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     adaptive_filtering: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     quality: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
@@ -255,11 +285,16 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         vertical: "vertical";
         horizontal: "horizontal";
+        grid: "grid";
     }>]>>;
     effect: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         mosaic: "mosaic";
         "polaroid-stack": "polaroid-stack";
     }>]>>;
+    columns: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    rows: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    cell_width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    cell_height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     border: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         none: "none";
@@ -280,6 +315,11 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     seed: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     shuffle: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    sort_by: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
+        basename: "basename";
+        import_order: "import_order";
+    }>]>>;
     coverage: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     adaptive_filtering: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     quality: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;

package/dist/v4/robots/image-merge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgHnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}
+{"version":3,"file":"image-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2JnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}

package/dist/v4/robots/image-merge.js

@@ -1,5 +1,5 @@
 import { z } from 'zod/v4';
-import { color_without_alpha_with_named, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { color_without_alpha_with_named, inputSortBySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
     bytescount: 1,
     discount_factor: 1,
@@ -41,7 +41,7 @@ export const robotImageMergeInstructionsSchema = robotBase
     .merge(robotUse)
     .extend({
     robot: z.literal('/image/merge').describe(`
-The final result will be a spritesheet, with the images displayed horizontally or vertically.
+The final result will be a spritesheet, with the images displayed horizontally, vertically, or in a grid layout.
 
 It's recommended to use this Robot with
 [🤖/image/resize](/docs/robots/image-resize/) so your images are of a
@@ -52,11 +52,13 @@ similar size before merging them.
         .default('png')
         .describe('The output format for the modified image.'),
     direction: z
-        .enum(['horizontal', 'vertical'])
+        .enum(['horizontal', 'vertical', 'grid'])
         .default('horizontal')
         .describe(`
 Specifies the direction which the images are displayed.
 
+Use \`grid\` to arrange inputs left-to-right and top-to-bottom.
+
 Only applies to the default spritesheet layout. Ignored when \`effect\` is set to \`polaroid-stack\` or \`mosaic\`, as those effects use their own layout algorithms.
 `),
     effect: z
@@ -66,6 +68,46 @@ Only applies to the default spritesheet layout. Ignored when \`effect\` is set t
 Applies a styled collage layout instead of a plain horizontal or vertical spritesheet.
 
 Currently supports \`polaroid-stack\`, which renders the inputs as overlapping instant photos on a canvas, and \`mosaic\`, which builds a justified tiled collage.
+`),
+    columns: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe(`
+Number of columns in the grid layout. Only applies when \`direction\` is \`grid\`.
+
+If omitted, columns are calculated automatically from the number of inputs and requested rows.
+`),
+    rows: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe(`
+Number of rows in the grid layout. Only applies when \`direction\` is \`grid\`.
+
+If omitted, rows are calculated automatically from the number of inputs and requested columns.
+`),
+    cell_width: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe(`
+Uniform width for each grid cell in pixels. Only applies when \`direction\` is \`grid\`.
+
+Images are resized to fit within the cell while preserving aspect ratio.
+`),
+    cell_height: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe(`
+Uniform height for each grid cell in pixels. Only applies when \`direction\` is \`grid\`.
+
+Images are resized to fit within the cell while preserving aspect ratio.
 `),
     // TODO: default is not between 1 and 10
     border: z
@@ -121,6 +163,7 @@ Optional deterministic seed used by styled effects such as \`polaroid-stack\` an
         .describe(`
 Whether styled effects such as \`polaroid-stack\` and \`mosaic\` may shuffle the input order before laying out the canvas.
 `),
+    sort_by: inputSortBySchema,
     coverage: z
         .number()
         .min(0.5)

package/dist/v4/robots/image-ocr.d.ts

@@ -34,21 +34,19 @@ export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/ocr">;
-    provider: z.ZodEnum<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
         aws: "aws";
         gcp: "gcp";
-        replicate: "replicate";
-        fal: "fal";
-        transloadit: "transloadit";
-    }>;
+    }>>;
     granularity: z.ZodDefault<z.ZodEnum<{
         full: "full";
         list: "list";
     }>>;
     format: z.ZodDefault<z.ZodEnum<{
         meta: "meta";
-        text: "text";
         json: "json";
+        text: "text";
     }>>;
 }, z.core.$strict>;
 export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObject<{
@@ -83,21 +81,19 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObjec
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/ocr">;
-    provider: z.ZodEnum<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
         aws: "aws";
         gcp: "gcp";
-        replicate: "replicate";
-        fal: "fal";
-        transloadit: "transloadit";
-    }>;
+    }>>;
     granularity: z.ZodDefault<z.ZodEnum<{
         full: "full";
         list: "list";
     }>>;
     format: z.ZodDefault<z.ZodEnum<{
         meta: "meta";
-        text: "text";
         json: "json";
+        text: "text";
     }>>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, z.core.$strict>;
@@ -136,21 +132,19 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/ocr">;
-    provider: z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    provider: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
         aws: "aws";
         gcp: "gcp";
-        replicate: "replicate";
-        fal: "fal";
-        transloadit: "transloadit";
-    }>]>;
+    }>]>>;
     granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         full: "full";
         list: "list";
     }>]>>;
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         meta: "meta";
-        text: "text";
         json: "json";
+        text: "text";
     }>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotImageOcrInstructions = InterpolatableRobotImageOcrInstructionsInput;
@@ -187,21 +181,19 @@ export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSche
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/ocr">;
-    provider: z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    provider: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
         aws: "aws";
         gcp: "gcp";
-        replicate: "replicate";
-        fal: "fal";
-        transloadit: "transloadit";
-    }>]>;
+    }>]>>;
     granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         full: "full";
         list: "list";
     }>]>>;
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         meta: "meta";
-        text: "text";
         json: "json";
+        text: "text";
     }>]>>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;

package/dist/v4/robots/image-ocr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-ocr.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-ocr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,IAAI,EAAE,cAwClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGxD,CAAA;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,4CAA4C,CAAA;AAElG,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzE,CAAA;AACD,MAAM,MAAM,uDAAuD,GAAG,CAAC,CAAC,KAAK,CAC3E,OAAO,6DAA6D,CACrE,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,6DAA6D,CACrE,CAAA"}
+{"version":3,"file":"image-ocr.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-ocr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAW1B,eAAO,MAAM,IAAI,EAAE,cAwClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGxD,CAAA;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,4CAA4C,CAAA;AAElG,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzE,CAAA;AACD,MAAM,MAAM,uDAAuD,GAAG,CAAC,CAAC,KAAK,CAC3E,OAAO,6DAA6D,CACrE,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,6DAA6D,CACrE,CAAA"}

package/dist/v4/robots/image-ocr.js

@@ -1,5 +1,5 @@
 import { z } from 'zod/v4';
-import { aiProviderSchema, granularitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { autoProviderDescription, awsGcpAiProviderSchema, granularitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
     bytescount: 1,
     discount_factor: 1,
@@ -49,10 +49,10 @@ With this <dfn>Robot</dfn> you can detect and extract text from images using opt
 
 For example, you can use the results to obtain the content of traffic signs, name tags, package labels and many more. You can also pass the text down to other <dfn>Robots</dfn> to filter images that contain (or do not contain) certain phrases. For images of dense documents, results may vary and be less accurate than for small pieces of text in photos.
 `),
-    provider: aiProviderSchema.describe(`
-Which AI provider to leverage.
+    provider: awsGcpAiProviderSchema.describe(`
+${autoProviderDescription}
 
-Transloadit outsources this task and abstracts the interface so you can expect the same data structures, but different latencies and information being returned. Different cloud vendors have different areas they shine in, and we recommend to try out and see what yields the best results for your use case.
+Set this to \`"aws"\` or \`"gcp"\` to force a specific provider.
 
 AWS supports detection for the following languages: English, Arabic, Russian, German, French, Italian, Portuguese and Spanish. GCP allows for a wider range of languages, with varying levels of support which can be found on the [official documentation](https://cloud.google.com/vision/docs/languages/).
 `),

package/dist/v4/robots/image-resize.d.ts

@@ -112,7 +112,7 @@ export declare const robotImageResizeInstructionsSchema: z.ZodObject<{
         x2: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         y2: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
     }, z.core.$strict>, z.ZodString]>>;
-    gravity: z.ZodDefault<z.ZodEnum<{
+    gravity: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
         left: "left";
         right: "right";
         bottom: "bottom";
@@ -122,7 +122,10 @@ export declare const robotImageResizeInstructionsSchema: z.ZodObject<{
         top: "top";
         "top-left": "top-left";
         "top-right": "top-right";
-    }>>;
+    }>, z.ZodEnum<{
+        attention: "attention";
+        entropy: "entropy";
+    }>]>>;
     strip: z.ZodDefault<z.ZodBoolean>;
     alpha: z.ZodOptional<z.ZodEnum<{
         Transparent: "Transparent";
@@ -476,7 +479,7 @@ export declare const robotImageResizeInstructionsWithHiddenFieldsSchema: z.ZodOb
         x2: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         y2: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
     }, z.core.$strict>, z.ZodString]>>;
-    gravity: z.ZodDefault<z.ZodEnum<{
+    gravity: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
         left: "left";
         right: "right";
         bottom: "bottom";
@@ -486,7 +489,10 @@ export declare const robotImageResizeInstructionsWithHiddenFieldsSchema: z.ZodOb
         top: "top";
         "top-left": "top-left";
         "top-right": "top-right";
-    }>>;
+    }>, z.ZodEnum<{
+        attention: "attention";
+        entropy: "entropy";
+    }>]>>;
     strip: z.ZodDefault<z.ZodBoolean>;
     alpha: z.ZodOptional<z.ZodEnum<{
         Transparent: "Transparent";
@@ -821,6 +827,7 @@ export declare const robotImageResizeInstructionsWithHiddenFieldsSchema: z.ZodOb
     watermark_position_y: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type RobotImageResizeInstructions = z.infer<typeof robotImageResizeInstructionsSchema>;
+export type RobotImageResizeInstructionsInput = z.input<typeof robotImageResizeInstructionsSchema>;
 export type RobotImageResizeInstructionsWithHiddenFields = z.infer<typeof robotImageResizeInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotImageResizeInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
@@ -869,7 +876,7 @@ export declare const interpolatableRobotImageResizeInstructionsSchema: z.ZodObje
         x2: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>>;
         y2: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>>;
     }, z.core.$strict>]>, z.ZodString]>>;
-    gravity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    gravity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         left: "left";
         right: "right";
         bottom: "bottom";
@@ -879,7 +886,10 @@ export declare const interpolatableRobotImageResizeInstructionsSchema: z.ZodObje
         top: "top";
         "top-left": "top-left";
         "top-right": "top-right";
-    }>]>>;
+    }>]>, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        attention: "attention";
+        entropy: "entropy";
+    }>]>]>>;
     strip: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     alpha: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         Transparent: "Transparent";
@@ -1235,7 +1245,7 @@ export declare const interpolatableRobotImageResizeInstructionsWithHiddenFieldsS
         x2: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>>;
         y2: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>>;
     }, z.core.$strict>]>, z.ZodString]>>;
-    gravity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    gravity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         left: "left";
         right: "right";
         bottom: "bottom";
@@ -1245,7 +1255,10 @@ export declare const interpolatableRobotImageResizeInstructionsWithHiddenFieldsS
         top: "top";
         "top-left": "top-left";
         "top-right": "top-right";
-    }>]>>;
+    }>]>, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        attention: "attention";
+        entropy: "entropy";
+    }>]>]>>;
     strip: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     alpha: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         Transparent: "Transparent";

package/dist/v4/robots/image-resize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-resize.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-resize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAiB1B,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsExB,CAAA;AAwBF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6cpC,CAAA;AAEX,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6C3D,CAAA;AAEJ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC7F,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5D,CAAA;AACD,MAAM,MAAM,0CAA0C,GACpD,+CAA+C,CAAA;AAEjD,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,gDAAgD,CACxD,CAAA;AAED,eAAO,MAAM,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5E,CAAA;AACD,MAAM,MAAM,0DAA0D,GAAG,CAAC,CAAC,KAAK,CAC9E,OAAO,gEAAgE,CACxE,CAAA;AACD,MAAM,MAAM,+DAA+D,GAAG,CAAC,CAAC,KAAK,CACnF,OAAO,gEAAgE,CACxE,CAAA"}
+{"version":3,"file":"image-resize.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-resize.ts"],"names":[],"mappings":"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"}

package/dist/v4/robots/image-resize.js

@@ -1,5 +1,7 @@
 import { z } from 'zod/v4';
-import { color_without_alpha_with_named, colorspaceSchema, complexHeightSchema, complexWidthSchema, imageQualitySchema, interpolateRobot, percentageSchema, positionSchema, robotBase, robotImagemagick, robotUse, unsafeCoordinatesSchema, } from "./_instructions-primitives.js";
+import { imagemagickDensityPattern } from "../imagemagickDensity.js";
+import { color_without_alpha_with_named, colorspaceSchema, complexHeightSchema, complexWidthSchema, httpUrlSchema, imageQualitySchema, interpolateRobot, percentageSchema, positionSchema, robotBase, robotImagemagick, robotUse, unsafeCoordinatesSchema, } from "./_instructions-primitives.js";
+const imageResizeGravitySchema = z.union([positionSchema, z.enum(['attention', 'entropy'])]);
 export const meta = {
     bytescount: 1,
     discount_factor: 1,
@@ -218,8 +220,10 @@ You can also use a JSON string of such an object with coordinates in similar fas
 
 To crop around human faces, see [🤖/image/facedetect](/docs/robots/image-facedetect/).
 `),
-    gravity: positionSchema.default('center').describe(`
-The direction from which the image is to be cropped, when \`"resize_strategy"\` is set to \`"crop"\`, but no crop coordinates are defined.
+    gravity: imageResizeGravitySchema.default('center').describe(`
+The direction from which the image is to be cropped when \`"resize_strategy"\` is set to \`"crop"\` or \`"fillcrop"\`, but no crop coordinates are defined.
+
+You can also use \`"entropy"\` or \`"attention"\` for automatic point-of-interest cropping. \`"entropy"\` keeps the region with the highest Shannon entropy, while \`"attention"\` favors areas with luminance frequency, saturation, and skin-tone cues.
 `),
     strip: z
         .boolean()
@@ -400,10 +404,7 @@ Changes the hue by rotating the color of the image. The value \`100\` would prod
         .describe(`
 Adjusts the contrast of the image. A value of \`1\` produces no change. Values below \`1\` decrease contrast (with \`0\` being minimum contrast), and values above \`1\` increase contrast (with \`2\` being maximum contrast). This works like the \`brightness\` parameter.
 `),
-    watermark_url: z
-        .string()
-        .optional()
-        .describe(`
+    watermark_url: httpUrlSchema.optional().describe(`
 A URL indicating a PNG image to be overlaid above this image. Please note that you can also  [supply the watermark via another Assembly Step](/docs/topics/use-parameter/#supplying-the-watermark-via-an-assembly-step). With watermarking you can add an image onto another image. This is usually used for logos.
 `),
     watermark_position: z
@@ -559,7 +560,7 @@ Example:
 `),
     density: z
         .string()
-        .regex(/\d+(x\d+)?/)
+        .regex(imagemagickDensityPattern)
         .nullable()
         .default(null)
         .describe(`

package/dist/v4/robots/image-upscale.d.ts

@@ -81,7 +81,7 @@ export declare const robotImageUpscaleInstructionsWithHiddenFieldsSchema: z.ZodO
     }>>;
     scale: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<2>, z.ZodLiteral<4>]>>;
     face_enhance: z.ZodOptional<z.ZodBoolean>;
-    provider: z.ZodOptional<z.ZodString>;
+    provider: z.ZodDefault<z.ZodString>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, z.core.$strict>;
 export type RobotImageUpscaleInstructions = z.infer<typeof robotImageUpscaleInstructionsSchema>;
@@ -168,7 +168,7 @@ export declare const interpolatableRobotImageUpscaleInstructionsWithHiddenFields
     }>]>>;
     scale: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<2>]>, z.ZodUnion<[z.ZodString, z.ZodLiteral<4>]>]>>;
     face_enhance: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    provider: z.ZodOptional<z.ZodString>;
+    provider: z.ZodDefault<z.ZodString>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotImageUpscaleInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema>;

package/dist/v4/robots/image-upscale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-upscale.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-upscale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAmClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiBrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}
+{"version":3,"file":"image-upscale.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-upscale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,IAAI,EAAE,cAmClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiBrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}

package/dist/v4/robots/image-upscale.js

@@ -1,5 +1,5 @@
 import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { autoProviderDescription, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
     bytescount: 1,
     discount_factor: 1,
@@ -55,7 +55,7 @@ export const robotImageUpscaleInstructionsSchema = robotBase
 })
     .strict();
 export const robotImageUpscaleInstructionsWithHiddenFieldsSchema = robotImageUpscaleInstructionsSchema.extend({
-    provider: z.string().optional().describe('Provider for upscaling the image.'),
+    provider: z.string().default('auto').describe(autoProviderDescription),
     result: z
         .union([z.literal('debug'), robotImageUpscaleInstructionsSchema.shape.result])
         .optional(),