@transloadit/zod 4.3.0 → 4.3.2

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

@@ -2,6 +2,13 @@ import { z } from 'zod/v4';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotImageGenerateInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
@@ -12,6 +19,7 @@ export declare const robotImageGenerateInstructionsSchema: z.ZodObject<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>>;
+    robot: z.ZodLiteral<"/image/generate">;
     use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         fields: z.ZodOptional<z.ZodString>;
@@ -26,7 +34,6 @@ export declare const robotImageGenerateInstructionsSchema: z.ZodObject<{
         group_by_original: z.ZodOptional<z.ZodBoolean>;
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
-    robot: z.ZodLiteral<"/image/generate">;
     model: z.ZodOptional<z.ZodString>;
     prompt: z.ZodString;
     format: z.ZodOptional<z.ZodEnum<{
@@ -45,6 +52,13 @@ export declare const robotImageGenerateInstructionsSchema: z.ZodObject<{
     num_outputs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export declare const robotImageGenerateInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -54,6 +68,7 @@ export declare const robotImageGenerateInstructionsWithHiddenFieldsSchema: z.Zod
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>>;
+    robot: z.ZodLiteral<"/image/generate">;
     use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         fields: z.ZodOptional<z.ZodString>;
@@ -68,7 +83,6 @@ export declare const robotImageGenerateInstructionsWithHiddenFieldsSchema: z.Zod
         group_by_original: z.ZodOptional<z.ZodBoolean>;
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
-    robot: z.ZodLiteral<"/image/generate">;
     model: z.ZodOptional<z.ZodString>;
     prompt: z.ZodString;
     format: z.ZodOptional<z.ZodEnum<{
@@ -91,6 +105,13 @@ export declare const robotImageGenerateInstructionsWithHiddenFieldsSchema: z.Zod
 export type RobotImageGenerateInstructions = z.infer<typeof robotImageGenerateInstructionsSchema>;
 export type RobotImageGenerateInstructionsWithHiddenFields = z.infer<typeof robotImageGenerateInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotImageGenerateInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
@@ -100,6 +121,7 @@ export declare const interpolatableRobotImageGenerateInstructionsSchema: z.ZodOb
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
+    robot: z.ZodLiteral<"/image/generate">;
     use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         fields: z.ZodOptional<z.ZodString>;
@@ -114,7 +136,6 @@ export declare const interpolatableRobotImageGenerateInstructionsSchema: z.ZodOb
         group_by_original: z.ZodOptional<z.ZodBoolean>;
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
-    robot: z.ZodLiteral<"/image/generate">;
     model: z.ZodOptional<z.ZodString>;
     prompt: z.ZodString;
     format: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
@@ -137,6 +158,13 @@ export declare const interpolatableRobotImageGenerateInstructionsSchema: z.ZodOb
 export type InterpolatableRobotImageGenerateInstructions = InterpolatableRobotImageGenerateInstructionsInput;
 export type InterpolatableRobotImageGenerateInstructionsInput = z.input<typeof interpolatableRobotImageGenerateInstructionsSchema>;
 export declare const interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
@@ -146,6 +174,7 @@ export declare const interpolatableRobotImageGenerateInstructionsWithHiddenField
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
+    robot: z.ZodLiteral<"/image/generate">;
     use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         fields: z.ZodOptional<z.ZodString>;
@@ -160,7 +189,6 @@ export declare const interpolatableRobotImageGenerateInstructionsWithHiddenField
         group_by_original: z.ZodOptional<z.ZodBoolean>;
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
-    robot: z.ZodLiteral<"/image/generate">;
     model: z.ZodOptional<z.ZodString>;
     prompt: z.ZodString;
     format: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{

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,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAyBlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0BtC,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,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,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,10 +1,27 @@
 import { z } from 'zod/v4';
 import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: true,
     bytescount: 1,
     discount_factor: 1,
     discount_pct: 0,
+    example_code: {
+        steps: {
+            ':original': {
+                robot: '/upload/handle',
+            },
+            inpainted: {
+                robot: '/image/generate',
+                use: [
+                    { name: ':original', as: 'image' },
+                    { name: ':original', as: 'mask' },
+                ],
+                model: 'google/nano-banana-pro',
+                prompt: 'Replace the masked area with a breaching whale. Keep the rest of the image unchanged.',
+                format: 'png',
+            },
+        },
+    },
+    example_code_description: 'Inpaint an image by uploading an original image and a mask image, then use both files in /image/generate.',
     minimum_charge: 0,
     output_factor: 0.6,
     purpose_sentence: 'generates images from text prompts using AI',
@@ -26,23 +43,60 @@ export const meta = {
     removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
     stage: 'ga',
 };
+// Internal documentation (for public docs, see transloadit.com/docs)
+//
+// Inpainting: When input files are provided via `use`, file metadata (field name, mime) is
+// prepended to the prompt so the model understands each file's role. Users should name upload
+// fields semantically (e.g., "mask", "image") or use the `as` directive. Field is checked first,
+// then `as`. Models that accept explicit image/mask inputs use these roles deterministically.
+// Models that infer roles from prompt context receive this file metadata in the prompt.
 export const robotImageGenerateInstructionsSchema = robotBase
     .merge(robotUse)
     .extend({
     robot: z.literal('/image/generate'),
+    use: robotUse.shape.use.describe(`
+Specifies which Step(s) to use as input.
+
+For inpainting, provide both the source image and mask through \`use\`, typically with:
+
+\`\`\`json
+{
+  "use": [
+    { "name": ":original", "as": "image" },
+    { "name": ":original", "as": "mask" }
+  ]
+}
+\`\`\`
+
+Best practice:
+- Tag source and mask inputs explicitly using \`as\` (or semantic upload field names)
+- Keep the prompt focused on what should change in the masked/transparent region
+- Leave the model/provider choice to the robot defaults unless you have a specific need
+`),
     model: z
         .string()
         .optional()
-        .describe('The AI model to use for image generation. Defaults to google/nano-banana.'),
-    prompt: z.string().describe('The prompt describing the desired image content.'),
+        .describe('The AI model to use. Defaults to google/nano-banana. Supported models include flux-1.1-pro-ultra, flux-schnell, recraft-v3, google/nano-banana, google/nano-banana-2, google/nano-banana-pro, openai/gpt-image-2, and stability-ai/stable-diffusion-inpainting. The legacy alias gpt-image-2 is also accepted for backwards compatibility.'),
+    prompt: z
+        .string()
+        .describe('Prompt describing the desired image. For inpainting, describe what should appear in the masked/transparent region and that the rest should stay unchanged.'),
     format: z
         .enum(['jpeg', 'jpg', 'png', 'gif', 'webp', 'svg'])
         .optional()
-        .describe('Format of the generated image.'),
+        .describe('Output format. Defaults depend on model: png for Google models and openai/gpt-image-2, svg for recraft-v3, jpeg for others. Google models currently return PNG only.'),
     seed: z.number().optional().describe('Seed for the random number generator.'),
-    aspect_ratio: z.string().optional().describe('Aspect ratio of the generated image.'),
-    height: z.number().optional().describe('Height of the generated image.'),
-    width: z.number().optional().describe('Width of the generated image.'),
+    aspect_ratio: z
+        .string()
+        .optional()
+        .describe('Requested output aspect ratio. For Google models, width/height can also be used and orientation is derived automatically when aspect_ratio is omitted.'),
+    height: z
+        .number()
+        .optional()
+        .describe('Requested output height in pixels (mainly used by Google image models and openai/gpt-image-2).'),
+    width: z
+        .number()
+        .optional()
+        .describe('Requested output width in pixels (mainly used by Google image models and openai/gpt-image-2).'),
     style: z.string().optional().describe('Style of the generated image.'),
     num_outputs: z
         .number()
@@ -50,7 +104,7 @@ export const robotImageGenerateInstructionsSchema = robotBase
         .min(1)
         .max(10)
         .optional()
-        .describe('Number of image variants to generate.'),
+        .describe('Number of output variants to generate (1-10).'),
 })
     .strict();
 export const robotImageGenerateInstructionsWithHiddenFieldsSchema = robotImageGenerateInstructionsSchema.extend({

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

@@ -2,6 +2,13 @@ import { z } from 'zod/v4';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
@@ -30,17 +37,48 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     format: z.ZodDefault<z.ZodEnum<{
         jpg: "jpg";
         png: "png";
+        webp: "webp";
     }>>;
     direction: z.ZodDefault<z.ZodEnum<{
-        horizontal: "horizontal";
         vertical: "vertical";
+        horizontal: "horizontal";
+    }>>;
+    effect: z.ZodOptional<z.ZodEnum<{
+        mosaic: "mosaic";
+        "polaroid-stack": "polaroid-stack";
     }>>;
     border: z.ZodDefault<z.ZodNumber>;
-    background: z.ZodDefault<z.ZodString>;
+    background: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
+        none: "none";
+        transparent: "transparent";
+        black: "black";
+        white: "white";
+        red: "red";
+        green: "green";
+        blue: "blue";
+        yellow: "yellow";
+        cyan: "cyan";
+        magenta: "magenta";
+        gray: "gray";
+        grey: "grey";
+        opaque: "opaque";
+    }>]>>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    shuffle: z.ZodDefault<z.ZodBoolean>;
+    coverage: z.ZodOptional<z.ZodNumber>;
     adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
     quality: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
 export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -68,13 +106,37 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     format: z.ZodDefault<z.ZodEnum<{
         jpg: "jpg";
         png: "png";
+        webp: "webp";
     }>>;
     direction: z.ZodDefault<z.ZodEnum<{
-        horizontal: "horizontal";
         vertical: "vertical";
+        horizontal: "horizontal";
+    }>>;
+    effect: z.ZodOptional<z.ZodEnum<{
+        mosaic: "mosaic";
+        "polaroid-stack": "polaroid-stack";
     }>>;
     border: z.ZodDefault<z.ZodNumber>;
-    background: z.ZodDefault<z.ZodString>;
+    background: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
+        none: "none";
+        transparent: "transparent";
+        black: "black";
+        white: "white";
+        red: "red";
+        green: "green";
+        blue: "blue";
+        yellow: "yellow";
+        cyan: "cyan";
+        magenta: "magenta";
+        gray: "gray";
+        grey: "grey";
+        opaque: "opaque";
+    }>]>>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    shuffle: z.ZodDefault<z.ZodBoolean>;
+    coverage: z.ZodOptional<z.ZodNumber>;
     adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
     quality: z.ZodDefault<z.ZodNumber>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
@@ -82,6 +144,13 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
 export type RobotImageMergeInstructions = z.infer<typeof robotImageMergeInstructionsSchema>;
 export type RobotImageMergeInstructionsWithHiddenFields = z.infer<typeof robotImageMergeInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
@@ -110,19 +179,50 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         jpg: "jpg";
         png: "png";
+        webp: "webp";
     }>]>>;
     direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        horizontal: "horizontal";
         vertical: "vertical";
+        horizontal: "horizontal";
+    }>]>>;
+    effect: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        mosaic: "mosaic";
+        "polaroid-stack": "polaroid-stack";
     }>]>>;
     border: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    background: z.ZodDefault<z.ZodString>;
+    background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        none: "none";
+        transparent: "transparent";
+        black: "black";
+        white: "white";
+        red: "red";
+        green: "green";
+        blue: "blue";
+        yellow: "yellow";
+        cyan: "cyan";
+        magenta: "magenta";
+        gray: "gray";
+        grey: "grey";
+        opaque: "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]>>;
+    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]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotImageMergeInstructions = InterpolatableRobotImageMergeInstructionsInput;
 export type InterpolatableRobotImageMergeInstructionsInput = z.input<typeof interpolatableRobotImageMergeInstructionsSchema>;
 export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
@@ -150,13 +250,37 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         jpg: "jpg";
         png: "png";
+        webp: "webp";
     }>]>>;
     direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        horizontal: "horizontal";
         vertical: "vertical";
+        horizontal: "horizontal";
+    }>]>>;
+    effect: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        mosaic: "mosaic";
+        "polaroid-stack": "polaroid-stack";
     }>]>>;
     border: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    background: z.ZodDefault<z.ZodString>;
+    background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        none: "none";
+        transparent: "transparent";
+        black: "black";
+        white: "white";
+        red: "red";
+        green: "green";
+        blue: "blue";
+        yellow: "yellow";
+        cyan: "cyan";
+        magenta: "magenta";
+        gray: "gray";
+        grey: "grey";
+        opaque: "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]>>;
+    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]>>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;

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,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AASnE,eAAO,MAAM,IAAI,EAAE,cAsClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2CnC,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,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAQnE,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"}

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

@@ -1,7 +1,6 @@
 import { z } from 'zod/v4';
-import { color_without_alpha, imageQualitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { color_without_alpha_with_named, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: true,
     bytescount: 1,
     discount_factor: 1,
     discount_pct: 0,
@@ -49,13 +48,25 @@ It's recommended to use this Robot with
 similar size before merging them.
 `),
     format: z
-        .enum(['jpg', 'png'])
+        .enum(['jpg', 'png', 'webp'])
         .default('png')
         .describe('The output format for the modified image.'),
     direction: z
         .enum(['horizontal', 'vertical'])
         .default('horizontal')
-        .describe('Specifies the direction which the images are displayed.'),
+        .describe(`
+Specifies the direction which the images are displayed.
+
+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
+        .enum(['mosaic', 'polaroid-stack'])
+        .optional()
+        .describe(`
+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.
+`),
     // TODO: default is not between 1 and 10
     border: z
         .number()
@@ -65,13 +76,62 @@ similar size before merging them.
 An integer value which defines the gap between images on the spritesheet.
 
 A value of \`10\` would cause the images to have the largest gap between them, while a value of \`1\` would place the images side-by-side.
+
+When \`effect\` is \`polaroid-stack\`, this value is instead used as canvas padding so the outermost photos keep that many pixels of distance from the edge.
+
+When \`effect\` is \`mosaic\`, this value is used both as the outer canvas padding and as the gutter width between neighbouring tiles.
 `),
-    background: color_without_alpha.default('#FFFFFF').describe(`
+    background: color_without_alpha_with_named.default('#fff').describe(`
 Either the hexadecimal code or [name](https://www.imagemagick.org/script/color.php#color_names) of the color used to fill the background (only shown with a border > 1).
 
-By default, the background of transparent images is changed to white.
+By default, the background of transparent images is changed to white. Set to \`none\` or \`transparent\` for a transparent canvas — requires \`format\` \`png\` or \`webp\` to preserve alpha.
 
 For details about how to preserve transparency across all image types, see [this demo](/demos/image-manipulation/properly-preserve-transparency-across-all-image-types/).
+`),
+    width: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe(`
+The output canvas width in pixels.
+
+This is mainly used by styled effects such as \`polaroid-stack\` and \`mosaic\`.
+`),
+    height: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe(`
+The output canvas height in pixels.
+
+This is mainly used by styled effects such as \`polaroid-stack\` and \`mosaic\`.
+`),
+    seed: z
+        .number()
+        .int()
+        .optional()
+        .describe(`
+Optional deterministic seed used by styled effects such as \`polaroid-stack\` and \`mosaic\`.
+`),
+    shuffle: z
+        .boolean()
+        .default(false)
+        .describe(`
+Whether styled effects such as \`polaroid-stack\` and \`mosaic\` may shuffle the input order before laying out the canvas.
+`),
+    coverage: z
+        .number()
+        .min(0.5)
+        .max(3)
+        .optional()
+        .describe(`
+Area-coverage multiplier for the \`polaroid-stack\` effect. Controls how large each polaroid is relative to the canvas and consequently how much of the canvas is covered by photos.
+
+The default of \`1.5\` leaves a subtle beige border along some edges. Use \`2.0\`–\`2.5\` for edge-to-edge coverage (photos overlap more). Values below \`1.0\` produce smaller, more widely spaced polaroids.
+
+Has no effect on the \`mosaic\` style or on plain spritesheets.
 `),
     adaptive_filtering: z
         .boolean()
@@ -79,7 +139,15 @@ For details about how to preserve transparency across all image types, see [this
         .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.
 `),
-    quality: imageQualitySchema,
+    quality: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .default(100)
+        .describe(`
+Controls the image compression for JPG, PNG, and WebP images. Please also take a look at [🤖/image/optimize](/docs/robots/image-optimize/).
+`),
 })
     .strict();
 export const robotImageMergeInstructionsWithHiddenFieldsSchema = robotImageMergeInstructionsSchema.extend({

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

@@ -2,6 +2,13 @@ import { z } from 'zod/v4';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
@@ -45,6 +52,13 @@ export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
     }>>;
 }, z.core.$strict>;
 export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -90,6 +104,13 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObjec
 export type RobotImageOcrInstructions = z.infer<typeof robotImageOcrInstructionsSchema>;
 export type RobotImageOcrInstructionsWithHiddenFields = z.infer<typeof robotImageOcrInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
@@ -135,6 +156,13 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<
 export type InterpolatableRobotImageOcrInstructions = InterpolatableRobotImageOcrInstructionsInput;
 export type InterpolatableRobotImageOcrInstructionsInput = z.input<typeof interpolatableRobotImageOcrInstructionsSchema>;
 export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";

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,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AASnE,eAAO,MAAM,IAAI,EAAE,cAyClB,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,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AASnE,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,7 +1,6 @@
 import { z } from 'zod/v4';
 import { aiProviderSchema, granularitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: true,
     bytescount: 1,
     discount_factor: 1,
     discount_pct: 0,