@transloadit/zod 4.3.3 → 4.3.5

package/dist/v3/robots/image-facedetect.d.ts

@@ -1,5 +1,33 @@
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 import { z } from 'zod/v3';
+export declare const imageFacedetectFaceSelectionModes: readonly ["each", "group", "max-confidence", "max-size"];
+export declare const imageFacedetectFaceSelectionModeSchema: z.ZodEnum<["each", "group", "max-confidence", "max-size"]>;
+export declare const imageFacedetectFaceCoordinatesSchema: z.ZodObject<{
+    confidence: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodNumber;
+    width: z.ZodNumber;
+    x1: z.ZodNumber;
+    x2: z.ZodOptional<z.ZodNumber>;
+    y1: z.ZodNumber;
+    y2: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    confidence: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodNumber;
+    width: z.ZodNumber;
+    x1: z.ZodNumber;
+    x2: z.ZodOptional<z.ZodNumber>;
+    y1: z.ZodNumber;
+    y2: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    confidence: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodNumber;
+    width: z.ZodNumber;
+    x1: z.ZodNumber;
+    x2: z.ZodOptional<z.ZodNumber>;
+    y1: z.ZodNumber;
+    y2: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+export type ImageFacedetectFaceCoordinates = z.infer<typeof imageFacedetectFaceCoordinatesSchema>;
 export declare const meta: RobotMetaInput;
 export declare const robotImageFacedetectInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
@@ -59,7 +87,7 @@ export declare const robotImageFacedetectInstructionsSchema: z.ZodObject<{
     }>]>>;
 } & {
     robot: z.ZodLiteral<"/image/facedetect">;
-    provider: z.ZodOptional<z.ZodEnum<["aws", "gcp", "replicate", "fal", "transloadit"]>>;
+    provider: z.ZodDefault<z.ZodEnum<["auto", "aws", "gcp"]>>;
     crop: z.ZodDefault<z.ZodBoolean>;
     crop_padding: z.ZodDefault<z.ZodString>;
     format: z.ZodDefault<z.ZodEnum<["jpg", "png", "preserve", "tiff"]>>;
@@ -72,6 +100,7 @@ export declare const robotImageFacedetectInstructionsSchema: z.ZodObject<{
     ignore_errors: string[];
     crop: boolean;
     format: "preserve" | "jpg" | "png" | "tiff";
+    provider: "auto" | "aws" | "gcp";
     crop_padding: string;
     min_confidence: number;
     faces: number | "each" | "group" | "max-confidence" | "max-size";
@@ -92,7 +121,6 @@ export declare const robotImageFacedetectInstructionsSchema: z.ZodObject<{
     } | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
-    provider?: "aws" | "gcp" | "replicate" | "fal" | "transloadit" | undefined;
 }, {
     robot: "/image/facedetect";
     interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
@@ -117,7 +145,7 @@ export declare const robotImageFacedetectInstructionsSchema: z.ZodObject<{
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
     crop?: boolean | undefined;
     format?: "preserve" | "jpg" | "png" | "tiff" | undefined;
-    provider?: "aws" | "gcp" | "replicate" | "fal" | "transloadit" | undefined;
+    provider?: "auto" | "aws" | "gcp" | undefined;
     crop_padding?: string | undefined;
     min_confidence?: number | undefined;
     faces?: number | "each" | "group" | "max-confidence" | "max-size" | undefined;
@@ -177,7 +205,7 @@ export declare const robotImageFacedetectInstructionsWithHiddenFieldsSchema: z.Z
         group_by_original?: boolean | undefined;
     }>]>>;
     robot: z.ZodLiteral<"/image/facedetect">;
-    provider: z.ZodOptional<z.ZodEnum<["aws", "gcp", "replicate", "fal", "transloadit"]>>;
+    provider: z.ZodDefault<z.ZodEnum<["auto", "aws", "gcp"]>>;
     crop: z.ZodDefault<z.ZodBoolean>;
     crop_padding: z.ZodDefault<z.ZodString>;
     format: z.ZodDefault<z.ZodEnum<["jpg", "png", "preserve", "tiff"]>>;
@@ -191,6 +219,7 @@ export declare const robotImageFacedetectInstructionsWithHiddenFieldsSchema: z.Z
     ignore_errors: string[];
     crop: boolean;
     format: "preserve" | "jpg" | "png" | "tiff";
+    provider: "auto" | "aws" | "gcp";
     crop_padding: string;
     min_confidence: number;
     faces: number | "each" | "group" | "max-confidence" | "max-size";
@@ -212,7 +241,6 @@ export declare const robotImageFacedetectInstructionsWithHiddenFieldsSchema: z.Z
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
-    provider?: "aws" | "gcp" | "replicate" | "fal" | "transloadit" | undefined;
 }, {
     robot: "/image/facedetect";
     interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
@@ -237,7 +265,7 @@ export declare const robotImageFacedetectInstructionsWithHiddenFieldsSchema: z.Z
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
     crop?: boolean | undefined;
     format?: "preserve" | "jpg" | "png" | "tiff" | undefined;
-    provider?: "aws" | "gcp" | "replicate" | "fal" | "transloadit" | undefined;
+    provider?: "auto" | "aws" | "gcp" | undefined;
     crop_padding?: string | undefined;
     min_confidence?: number | undefined;
     faces?: number | "each" | "group" | "max-confidence" | "max-size" | undefined;
@@ -300,7 +328,7 @@ export declare const interpolatableRobotImageFacedetectInstructionsSchema: z.Zod
         group_by_original?: boolean | undefined;
     }>]>>;
     robot: z.ZodLiteral<"/image/facedetect">;
-    provider: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["aws", "gcp", "replicate", "fal", "transloadit"]>]>>;
+    provider: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["auto", "aws", "gcp"]>]>>;
     crop: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     crop_padding: z.ZodDefault<z.ZodString>;
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["jpg", "png", "preserve", "tiff"]>]>>;
@@ -313,6 +341,7 @@ export declare const interpolatableRobotImageFacedetectInstructionsSchema: z.Zod
     ignore_errors: string | string[];
     crop: string | boolean;
     format: string;
+    provider: string;
     crop_padding: string;
     min_confidence: string | number;
     faces: string | number;
@@ -333,7 +362,6 @@ export declare const interpolatableRobotImageFacedetectInstructionsSchema: z.Zod
     } | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     queue?: string | undefined;
-    provider?: string | undefined;
 }, {
     robot: "/image/facedetect";
     interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
@@ -420,7 +448,7 @@ export declare const interpolatableRobotImageFacedetectInstructionsWithHiddenFie
         group_by_original?: boolean | undefined;
     }>]>>;
     robot: z.ZodLiteral<"/image/facedetect">;
-    provider: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["aws", "gcp", "replicate", "fal", "transloadit"]>]>>;
+    provider: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["auto", "aws", "gcp"]>]>>;
     crop: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     crop_padding: z.ZodDefault<z.ZodString>;
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["jpg", "png", "preserve", "tiff"]>]>>;
@@ -433,6 +461,7 @@ export declare const interpolatableRobotImageFacedetectInstructionsWithHiddenFie
     ignore_errors: string | string[];
     crop: string | boolean;
     format: string;
+    provider: string;
     crop_padding: string;
     min_confidence: string | number;
     faces: string | number;
@@ -454,7 +483,6 @@ export declare const interpolatableRobotImageFacedetectInstructionsWithHiddenFie
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
     queue?: string | undefined;
-    provider?: string | undefined;
 }, {
     robot: "/image/facedetect";
     interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;

package/dist/v3/robots/image-facedetect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-facedetect.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/image-facedetect.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,cAuClB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqGxC,CAAA;AAEX,eAAO,MAAM,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK/D,CAAA;AAEJ,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AACD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEhE,CAAA;AACD,MAAM,MAAM,8CAA8C,GACxD,mDAAmD,CAAA;AAErD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACP,CAAA;AAC1E,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,oEAAoE,CAC5E,CAAA;AACD,MAAM,MAAM,mEAAmE,GAAG,CAAC,CAAC,KAAK,CACvF,OAAO,oEAAoE,CAC5E,CAAA"}
+{"version":3,"file":"image-facedetect.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/image-facedetect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,iCAAiC,0DAKpC,CAAA;AAEV,eAAO,MAAM,sCAAsC,4DAA4C,CAAA;AAE/F,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;gCAUjC,CAAA;AAEhB,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AAEjG,eAAO,MAAM,IAAI,EAAE,cAuClB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqGxC,CAAA;AAEX,eAAO,MAAM,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK/D,CAAA;AAEJ,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AACD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEhE,CAAA;AACD,MAAM,MAAM,8CAA8C,GACxD,mDAAmD,CAAA;AAErD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACP,CAAA;AAC1E,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,oEAAoE,CAC5E,CAAA;AACD,MAAM,MAAM,mEAAmE,GAAG,CAAC,CAAC,KAAK,CACvF,OAAO,oEAAoE,CAC5E,CAAA"}

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

@@ -1,5 +1,23 @@
 import { z } from 'zod/v3';
-import { aiProviderSchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { autoProviderDescription, awsGcpAiProviderSchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+export const imageFacedetectFaceSelectionModes = [
+    'each',
+    'group',
+    'max-confidence',
+    'max-size',
+];
+export const imageFacedetectFaceSelectionModeSchema = z.enum(imageFacedetectFaceSelectionModes);
+export const imageFacedetectFaceCoordinatesSchema = z
+    .object({
+    confidence: z.number().optional(),
+    height: z.number(),
+    width: z.number(),
+    x1: z.number(),
+    x2: z.number().optional(),
+    y1: z.number(),
+    y2: z.number().optional(),
+})
+    .passthrough();
 export const meta = {
     bytescount: 1,
     discount_factor: 1,
@@ -56,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()
@@ -92,7 +110,7 @@ The default value \`"preserve"\` means that the input image format is re-used.
 Specifies the minimum confidence that a detected face must have. Only faces which have a higher confidence value than this threshold will be included in the result.
 `),
     faces: z
-        .union([z.enum(['each', 'group', 'max-confidence', 'max-size']), z.number().int()])
+        .union([imageFacedetectFaceSelectionModeSchema, z.number().int()])
         .default('each')
         .describe(`
 Determines which of the detected faces should be returned. Valid values are:

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

@@ -195,12 +195,13 @@ export declare const robotImageGenerateInstructionsWithHiddenFieldsSchema: z.Zod
     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<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/image/generate";
     force_accept: boolean;
     ignore_errors: string[];
+    provider: string;
     prompt: string;
     interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
@@ -224,7 +225,6 @@ export declare const robotImageGenerateInstructionsWithHiddenFieldsSchema: z.Zod
     height?: number | undefined;
     model?: string | undefined;
     format?: "gif" | "jpeg" | "jpg" | "png" | "svg" | "webp" | undefined;
-    provider?: string | undefined;
     style?: string | undefined;
     seed?: number | undefined;
     aspect_ratio?: string | undefined;
@@ -328,12 +328,13 @@ 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]>>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/image/generate";
     force_accept: string | boolean;
     ignore_errors: string | string[];
+    provider: string;
     prompt: string;
     interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
@@ -357,7 +358,6 @@ export declare const interpolatableRobotImageGenerateInstructionsSchema: z.ZodOb
     height?: string | number | undefined;
     model?: string | undefined;
     format?: string | undefined;
-    provider?: string | undefined;
     style?: string | undefined;
     seed?: string | number | undefined;
     aspect_ratio?: string | undefined;
@@ -461,12 +461,13 @@ 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]>>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/image/generate";
     force_accept: string | boolean;
     ignore_errors: string | string[];
+    provider: string;
     prompt: string;
     interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
@@ -490,7 +491,6 @@ export declare const interpolatableRobotImageGenerateInstructionsWithHiddenField
     height?: string | number | undefined;
     model?: string | undefined;
     format?: string | undefined;
-    provider?: string | undefined;
     style?: string | undefined;
     seed?: string | number | undefined;
     aspect_ratio?: string | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"image-generate.d.ts","sourceRoot":"","sources":["../../../src/v3/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsEtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM7D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9E,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/v3/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsEtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM7D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9E,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/v3/robots/image-generate.js

@@ -1,5 +1,5 @@
 import { z } from 'zod/v3';
-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/v3/robots/image-merge.d.ts

@@ -60,14 +60,19 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
 } & {
     robot: z.ZodLiteral<"/image/merge">;
     format: z.ZodDefault<z.ZodEnum<["jpg", "png", "webp"]>>;
-    direction: z.ZodDefault<z.ZodEnum<["horizontal", "vertical"]>>;
+    direction: z.ZodDefault<z.ZodEnum<["horizontal", "vertical", "grid"]>>;
     effect: z.ZodOptional<z.ZodEnum<["mosaic", "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<[z.ZodString, z.ZodEnum<["transparent", "none", "black", "white", "red", "green", "blue", "yellow", "cyan", "magenta", "gray", "grey", "opaque"]>]>>;
     width: z.ZodOptional<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;
     seed: z.ZodOptional<z.ZodNumber>;
     shuffle: z.ZodDefault<z.ZodBoolean>;
+    sort_by: z.ZodDefault<z.ZodEnum<["auto", "basename", "import_order"]>>;
     coverage: z.ZodOptional<z.ZodNumber>;
     adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
     quality: z.ZodDefault<z.ZodNumber>;
@@ -78,8 +83,9 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     ignore_errors: string[];
     background: string;
     format: "jpg" | "png" | "webp";
+    sort_by: "auto" | "basename" | "import_order";
     quality: number;
-    direction: "vertical" | "horizontal";
+    direction: "vertical" | "horizontal" | "grid";
     border: number;
     shuffle: boolean;
     adaptive_filtering: boolean;
@@ -104,6 +110,10 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     width?: number | undefined;
     height?: number | undefined;
     seed?: number | undefined;
+    columns?: number | undefined;
+    rows?: number | undefined;
+    cell_width?: number | undefined;
+    cell_height?: number | undefined;
     coverage?: number | undefined;
 }, {
     robot: "/image/merge";
@@ -132,9 +142,14 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     height?: number | undefined;
     background?: string | undefined;
     format?: "jpg" | "png" | "webp" | undefined;
+    sort_by?: "auto" | "basename" | "import_order" | undefined;
     quality?: number | undefined;
     seed?: number | undefined;
-    direction?: "vertical" | "horizontal" | undefined;
+    direction?: "vertical" | "horizontal" | "grid" | undefined;
+    columns?: number | undefined;
+    rows?: number | undefined;
+    cell_width?: number | undefined;
+    cell_height?: number | undefined;
     border?: number | undefined;
     shuffle?: boolean | undefined;
     coverage?: number | undefined;
@@ -196,14 +211,19 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     }>]>>;
     robot: z.ZodLiteral<"/image/merge">;
     format: z.ZodDefault<z.ZodEnum<["jpg", "png", "webp"]>>;
-    direction: z.ZodDefault<z.ZodEnum<["horizontal", "vertical"]>>;
+    direction: z.ZodDefault<z.ZodEnum<["horizontal", "vertical", "grid"]>>;
     effect: z.ZodOptional<z.ZodEnum<["mosaic", "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<[z.ZodString, z.ZodEnum<["transparent", "none", "black", "white", "red", "green", "blue", "yellow", "cyan", "magenta", "gray", "grey", "opaque"]>]>>;
     width: z.ZodOptional<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;
     seed: z.ZodOptional<z.ZodNumber>;
     shuffle: z.ZodDefault<z.ZodBoolean>;
+    sort_by: z.ZodDefault<z.ZodEnum<["auto", "basename", "import_order"]>>;
     coverage: z.ZodOptional<z.ZodNumber>;
     adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
     quality: z.ZodDefault<z.ZodNumber>;
@@ -215,8 +235,9 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     ignore_errors: string[];
     background: string;
     format: "jpg" | "png" | "webp";
+    sort_by: "auto" | "basename" | "import_order";
     quality: number;
-    direction: "vertical" | "horizontal";
+    direction: "vertical" | "horizontal" | "grid";
     border: number;
     shuffle: boolean;
     adaptive_filtering: boolean;
@@ -242,6 +263,10 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     width?: number | undefined;
     height?: number | undefined;
     seed?: number | undefined;
+    columns?: number | undefined;
+    rows?: number | undefined;
+    cell_width?: number | undefined;
+    cell_height?: number | undefined;
     coverage?: number | undefined;
 }, {
     robot: "/image/merge";
@@ -270,9 +295,14 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     height?: number | undefined;
     background?: string | undefined;
     format?: "jpg" | "png" | "webp" | undefined;
+    sort_by?: "auto" | "basename" | "import_order" | undefined;
     quality?: number | undefined;
     seed?: number | undefined;
-    direction?: "vertical" | "horizontal" | undefined;
+    direction?: "vertical" | "horizontal" | "grid" | undefined;
+    columns?: number | undefined;
+    rows?: number | undefined;
+    cell_width?: number | undefined;
+    cell_height?: number | undefined;
     border?: number | undefined;
     shuffle?: boolean | undefined;
     coverage?: number | undefined;
@@ -337,14 +367,19 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     }>]>>;
     robot: z.ZodLiteral<"/image/merge">;
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["jpg", "png", "webp"]>]>>;
-    direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["horizontal", "vertical"]>]>>;
+    direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["horizontal", "vertical", "grid"]>]>>;
     effect: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["mosaic", "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<["transparent", "none", "black", "white", "red", "green", "blue", "yellow", "cyan", "magenta", "gray", "grey", "opaque"]>]>]>>;
     width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     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", "basename", "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]>>;
@@ -355,6 +390,7 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     ignore_errors: string | string[];
     background: string;
     format: string;
+    sort_by: string;
     quality: string | number;
     direction: string;
     border: string | number;
@@ -381,6 +417,10 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     width?: string | number | undefined;
     height?: string | number | undefined;
     seed?: string | number | undefined;
+    columns?: string | number | undefined;
+    rows?: string | number | undefined;
+    cell_width?: string | number | undefined;
+    cell_height?: string | number | undefined;
     coverage?: string | number | undefined;
 }, {
     robot: "/image/merge";
@@ -409,9 +449,14 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     height?: string | number | undefined;
     background?: string | undefined;
     format?: string | undefined;
+    sort_by?: string | undefined;
     quality?: string | number | undefined;
     seed?: string | number | undefined;
     direction?: string | undefined;
+    columns?: string | number | undefined;
+    rows?: string | number | undefined;
+    cell_width?: string | number | undefined;
+    cell_height?: string | number | undefined;
     border?: string | number | undefined;
     shuffle?: string | boolean | undefined;
     coverage?: string | number | undefined;
@@ -475,14 +520,19 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     }>]>>;
     robot: z.ZodLiteral<"/image/merge">;
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["jpg", "png", "webp"]>]>>;
-    direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["horizontal", "vertical"]>]>>;
+    direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["horizontal", "vertical", "grid"]>]>>;
     effect: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["mosaic", "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<["transparent", "none", "black", "white", "red", "green", "blue", "yellow", "cyan", "magenta", "gray", "grey", "opaque"]>]>]>>;
     width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     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", "basename", "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]>>;
@@ -493,6 +543,7 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     ignore_errors: string | string[];
     background: string;
     format: string;
+    sort_by: string;
     quality: string | number;
     direction: string;
     border: string | number;
@@ -520,6 +571,10 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     width?: string | number | undefined;
     height?: string | number | undefined;
     seed?: string | number | undefined;
+    columns?: string | number | undefined;
+    rows?: string | number | undefined;
+    cell_width?: string | number | undefined;
+    cell_height?: string | number | undefined;
     coverage?: string | number | undefined;
 }, {
     robot: "/image/merge";
@@ -548,9 +603,14 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     height?: string | number | undefined;
     background?: string | undefined;
     format?: string | undefined;
+    sort_by?: string | undefined;
     quality?: string | number | undefined;
     seed?: string | number | undefined;
     direction?: string | undefined;
+    columns?: string | number | undefined;
+    rows?: string | number | undefined;
+    cell_width?: string | number | undefined;
+    cell_height?: string | number | undefined;
     border?: string | number | undefined;
     shuffle?: string | boolean | undefined;
     coverage?: string | number | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"image-merge.d.ts","sourceRoot":"","sources":["../../../src/v3/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgHnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK1D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3E,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/v3/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2JnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK1D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3E,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/v3/robots/image-merge.js

@@ -1,5 +1,5 @@
 import { z } from 'zod/v3';
-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)