@transloadit/zod 4.3.0 → 4.3.2

package/dist/v4/robots/document-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 robotDocumentMergeInstructionsSchema: 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<{
@@ -31,6 +38,13 @@ export declare const robotDocumentMergeInstructionsSchema: z.ZodObject<{
     output_password: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const robotDocumentMergeInstructionsWithHiddenFieldsSchema: 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";
@@ -62,6 +76,13 @@ export declare const robotDocumentMergeInstructionsWithHiddenFieldsSchema: z.Zod
 export type RobotDocumentMergeInstructions = z.infer<typeof robotDocumentMergeInstructionsSchema>;
 export type RobotDocumentMergeInstructionsWithHiddenFields = z.infer<typeof robotDocumentMergeInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDocumentMergeInstructionsSchema: 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<{
@@ -93,6 +114,13 @@ export declare const interpolatableRobotDocumentMergeInstructionsSchema: z.ZodOb
 export type InterpolatableRobotDocumentMergeInstructions = InterpolatableRobotDocumentMergeInstructionsInput;
 export type InterpolatableRobotDocumentMergeInstructionsInput = z.input<typeof interpolatableRobotDocumentMergeInstructionsSchema>;
 export declare const interpolatableRobotDocumentMergeInstructionsWithHiddenFieldsSchema: 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/document-merge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-merge.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,cAqDlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqBtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7D,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":"document-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-merge.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,cAoDlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqBtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7D,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/document-merge.js

@@ -1,7 +1,6 @@
 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,

package/dist/v4/robots/document-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 robotDocumentOcrInstructionsSchema: 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 robotDocumentOcrInstructionsSchema: z.ZodObject<{
     }>>;
 }, z.core.$strict>;
 export declare const robotDocumentOcrInstructionsWithHiddenFieldsSchema: 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 robotDocumentOcrInstructionsWithHiddenFieldsSchema: z.ZodOb
 export type RobotDocumentOcrInstructions = z.infer<typeof robotDocumentOcrInstructionsSchema>;
 export type RobotDocumentOcrInstructionsWithHiddenFields = z.infer<typeof robotDocumentOcrInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDocumentOcrInstructionsSchema: 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 interpolatableRobotDocumentOcrInstructionsSchema: z.ZodObje
 export type InterpolatableRobotDocumentOcrInstructions = InterpolatableRobotDocumentOcrInstructionsInput;
 export type InterpolatableRobotDocumentOcrInstructionsInput = z.input<typeof interpolatableRobotDocumentOcrInstructionsSchema>;
 export declare const interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsSchema: 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/document-ocr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-ocr.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-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,cA8ClB,CAAA;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BpC,CAAA;AAEX,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK3D,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":"document-ocr.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-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,cA6ClB,CAAA;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BpC,CAAA;AAEX,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK3D,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"}

package/dist/v4/robots/document-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,

package/dist/v4/robots/document-optimize.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 robotDocumentOptimizeInstructionsSchema: 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<{
@@ -47,6 +54,13 @@ export declare const robotDocumentOptimizeInstructionsSchema: z.ZodObject<{
     }>>;
 }, z.core.$strict>;
 export declare const robotDocumentOptimizeInstructionsWithHiddenFieldsSchema: 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";
@@ -94,6 +108,13 @@ export declare const robotDocumentOptimizeInstructionsWithHiddenFieldsSchema: z.
 export type RobotDocumentOptimizeInstructions = z.infer<typeof robotDocumentOptimizeInstructionsSchema>;
 export type RobotDocumentOptimizeInstructionsWithHiddenFields = z.infer<typeof robotDocumentOptimizeInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDocumentOptimizeInstructionsSchema: 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<{
@@ -141,6 +162,13 @@ export declare const interpolatableRobotDocumentOptimizeInstructionsSchema: z.Zo
 export type InterpolatableRobotDocumentOptimizeInstructions = InterpolatableRobotDocumentOptimizeInstructionsInput;
 export type InterpolatableRobotDocumentOptimizeInstructionsInput = z.input<typeof interpolatableRobotDocumentOptimizeInstructionsSchema>;
 export declare const interpolatableRobotDocumentOptimizeInstructionsWithHiddenFieldsSchema: 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/document-optimize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-optimize.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-optimize.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,cAyDlB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkFzC,CAAA;AAEX,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKhE,CAAA;AAEJ,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEjE,CAAA;AACD,MAAM,MAAM,+CAA+C,GACzD,oDAAoD,CAAA;AAEtD,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CACxE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,qEAAqE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,CAAA;AAC3E,MAAM,MAAM,+DAA+D,GAAG,CAAC,CAAC,KAAK,CACnF,OAAO,qEAAqE,CAC7E,CAAA;AACD,MAAM,MAAM,oEAAoE,GAAG,CAAC,CAAC,KAAK,CACxF,OAAO,qEAAqE,CAC7E,CAAA"}
+{"version":3,"file":"document-optimize.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-optimize.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,cAwDlB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkFzC,CAAA;AAEX,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKhE,CAAA;AAEJ,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEjE,CAAA;AACD,MAAM,MAAM,+CAA+C,GACzD,oDAAoD,CAAA;AAEtD,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CACxE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,qEAAqE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,CAAA;AAC3E,MAAM,MAAM,+DAA+D,GAAG,CAAC,CAAC,KAAK,CACnF,OAAO,qEAAqE,CAC7E,CAAA;AACD,MAAM,MAAM,oEAAoE,GAAG,CAAC,CAAC,KAAK,CACxF,OAAO,qEAAqE,CAC7E,CAAA"}

package/dist/v4/robots/document-optimize.js

@@ -1,7 +1,6 @@
 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,

package/dist/v4/robots/document-split.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 robotDocumentSplitInstructionsSchema: 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,6 +37,13 @@ export declare const robotDocumentSplitInstructionsSchema: z.ZodObject<{
     pages: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
 }, z.core.$strict>;
 export declare const robotDocumentSplitInstructionsWithHiddenFieldsSchema: 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";
@@ -60,6 +74,13 @@ export declare const robotDocumentSplitInstructionsWithHiddenFieldsSchema: z.Zod
 export type RobotDocumentSplitInstructions = z.infer<typeof robotDocumentSplitInstructionsSchema>;
 export type RobotDocumentSplitInstructionsWithHiddenFields = z.infer<typeof robotDocumentSplitInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDocumentSplitInstructionsSchema: 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<{
@@ -90,6 +111,13 @@ export declare const interpolatableRobotDocumentSplitInstructionsSchema: z.ZodOb
 export type InterpolatableRobotDocumentSplitInstructions = InterpolatableRobotDocumentSplitInstructionsInput;
 export type InterpolatableRobotDocumentSplitInstructionsInput = z.input<typeof interpolatableRobotDocumentSplitInstructionsSchema>;
 export declare const interpolatableRobotDocumentSplitInstructionsWithHiddenFieldsSchema: 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/document-split.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-split.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-split.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,cA2BlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAWtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7D,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":"document-split.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-split.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,cAmClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAWtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7D,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/document-split.js

@@ -1,10 +1,18 @@
 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: {
+            extracted_pages: {
+                robot: '/document/split',
+                use: ':original',
+                pages: ['1', '3-5'],
+            },
+        },
+    },
     example_code_description: 'Extract single or multiple pages from a PDF document:',
     minimum_charge: 2097152,
     output_factor: 1,

package/dist/v4/robots/document-thumbs.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 robotDocumentThumbsInstructionsSchema: 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<{
@@ -31,6 +38,7 @@ export declare const robotDocumentThumbsInstructionsSchema: z.ZodObject<{
     }>, z.ZodString]>>;
     robot: z.ZodLiteral<"/document/thumbs">;
     page: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    page_range: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     format: z.ZodDefault<z.ZodEnum<{
         gif: "gif";
         jpeg: "jpeg";
@@ -38,6 +46,11 @@ export declare const robotDocumentThumbsInstructionsSchema: z.ZodObject<{
         png: "png";
     }>>;
     delay: z.ZodOptional<z.ZodNumber>;
+    stack: z.ZodOptional<z.ZodEnum<{
+        ghostscript: "ghostscript";
+        vips: "vips";
+        pdfium: "pdfium";
+    }>>;
     width: z.ZodOptional<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;
     resize_strategy: z.ZodDefault<z.ZodEnum<{
@@ -97,6 +110,13 @@ export declare const robotDocumentThumbsInstructionsSchema: z.ZodObject<{
     turbo: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
 export declare const robotDocumentThumbsInstructionsWithHiddenFieldsSchema: 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";
@@ -125,6 +145,7 @@ export declare const robotDocumentThumbsInstructionsWithHiddenFieldsSchema: z.Zo
     }>, z.ZodString]>>;
     robot: z.ZodLiteral<"/document/thumbs">;
     page: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    page_range: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     format: z.ZodDefault<z.ZodEnum<{
         gif: "gif";
         jpeg: "jpeg";
@@ -178,7 +199,12 @@ export declare const robotDocumentThumbsInstructionsWithHiddenFieldsSchema: z.Zo
     pdf_use_cropbox: z.ZodDefault<z.ZodBoolean>;
     turbo: z.ZodDefault<z.ZodBoolean>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-    stack: z.ZodOptional<z.ZodString>;
+    stack: z.ZodOptional<z.ZodEnum<{
+        imagemagick: "imagemagick";
+        ghostscript: "ghostscript";
+        vips: "vips";
+        pdfium: "pdfium";
+    }>>;
     alpha: z.ZodOptional<z.ZodEnum<{
         set: "set";
         remove: "remove";
@@ -198,6 +224,13 @@ export declare const robotDocumentThumbsInstructionsWithHiddenFieldsSchema: z.Zo
 export type RobotDocumentThumbsInstructions = z.infer<typeof robotDocumentThumbsInstructionsSchema>;
 export type RobotDocumentThumbsInstructionsWithHiddenFields = z.infer<typeof robotDocumentThumbsInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDocumentThumbsInstructionsSchema: 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<{
@@ -227,6 +260,7 @@ export declare const interpolatableRobotDocumentThumbsInstructionsSchema: z.ZodO
     }>]>, z.ZodString]>>;
     robot: z.ZodLiteral<"/document/thumbs">;
     page: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodNumber]>>>;
+    page_range: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         gif: "gif";
         jpeg: "jpeg";
@@ -234,6 +268,11 @@ export declare const interpolatableRobotDocumentThumbsInstructionsSchema: z.ZodO
         png: "png";
     }>]>>;
     delay: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    stack: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        ghostscript: "ghostscript";
+        vips: "vips";
+        pdfium: "pdfium";
+    }>]>>;
     width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     resize_strategy: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
@@ -295,6 +334,13 @@ export declare const interpolatableRobotDocumentThumbsInstructionsSchema: z.ZodO
 export type InterpolatableRobotDocumentThumbsInstructions = InterpolatableRobotDocumentThumbsInstructionsInput;
 export type InterpolatableRobotDocumentThumbsInstructionsInput = z.input<typeof interpolatableRobotDocumentThumbsInstructionsSchema>;
 export declare const interpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsSchema: 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";
@@ -323,6 +369,7 @@ export declare const interpolatableRobotDocumentThumbsInstructionsWithHiddenFiel
     }>]>, z.ZodString]>>;
     robot: z.ZodLiteral<"/document/thumbs">;
     page: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodNumber]>>>;
+    page_range: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         gif: "gif";
         jpeg: "jpeg";
@@ -376,7 +423,12 @@ export declare const interpolatableRobotDocumentThumbsInstructionsWithHiddenFiel
     pdf_use_cropbox: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     turbo: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
-    stack: z.ZodOptional<z.ZodString>;
+    stack: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        imagemagick: "imagemagick";
+        ghostscript: "ghostscript";
+        vips: "vips";
+        pdfium: "pdfium";
+    }>]>>;
     alpha: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         set: "set";
         remove: "remove";

package/dist/v4/robots/document-thumbs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-thumbs.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-thumbs.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,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6HvC,CAAA;AAEX,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyB9D,CAAA;AAEJ,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA;AACnG,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE/D,CAAA;AACD,MAAM,MAAM,6CAA6C,GACvD,kDAAkD,CAAA;AAEpD,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,KAAK,CACtE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE/E,CAAA;AACD,MAAM,MAAM,6DAA6D,GAAG,CAAC,CAAC,KAAK,CACjF,OAAO,mEAAmE,CAC3E,CAAA;AACD,MAAM,MAAM,kEAAkE,GAAG,CAAC,CAAC,KAAK,CACtF,OAAO,mEAAmE,CAC3E,CAAA"}
+{"version":3,"file":"document-thumbs.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-thumbs.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,cAuClB,CAAA;AAED,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkKvC,CAAA;AAEX,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyB9D,CAAA;AAEJ,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA;AACnG,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE/D,CAAA;AACD,MAAM,MAAM,6CAA6C,GACvD,kDAAkD,CAAA;AAEpD,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,KAAK,CACtE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE/E,CAAA;AACD,MAAM,MAAM,6DAA6D,GAAG,CAAC,CAAC,KAAK,CACjF,OAAO,mEAAmE,CAC3E,CAAA;AACD,MAAM,MAAM,kEAAkE,GAAG,CAAC,CAAC,KAAK,CACtF,OAAO,mEAAmE,CAC3E,CAAA"}

package/dist/v4/robots/document-thumbs.js

@@ -1,7 +1,6 @@
 import { z } from 'zod/v4';
 import { colorspaceSchema, interpolateRobot, robotBase, robotImagemagick, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: true,
     bytescount: 1,
     discount_factor: 1,
     discount_pct: 0,
@@ -57,6 +56,20 @@ export const robotDocumentThumbsInstructionsSchema = robotBase
         .default(null)
         .describe(`
 The PDF page that you want to convert to an image. By default the value is \`null\` which means that all pages will be converted into images.
+`),
+    page_range: z
+        .string()
+        .regex(/^\d+-\d+$/)
+        .refine((val) => {
+        const [start, end] = val.split('-').map(Number);
+        return start >= 1 && end >= start;
+    }, { message: 'Start must be ≥ 1 and end must be ≥ start (e.g. "1-20")' })
+        .nullable()
+        .default(null)
+        .describe(`
+A page range to extract, in the format \`"start-end"\` (e.g., \`"1-20"\`). Extraction starts from the first page in the range and proceeds sequentially, stopping gracefully when a page does not exist. This is useful for PDFs where the total page count cannot be determined.
+
+This parameter cannot be used together with \`page\`, and is not supported with GIF format. When \`page_range\` is set, the robot does not need to know the total page count upfront, making it robust for PDFs that fail page count detection.
 `),
     format: z
         .enum(['gif', 'jpeg', 'jpg', 'png'])
@@ -75,6 +88,20 @@ If you specify the value \`"gif"\`, then an animated gif cycling through all pag
 If your output format is \`"gif"\` then this parameter sets the number of 100th seconds to pass before the next frame is shown in the animation. Set this to \`100\` for example to allow 1 second to pass between the frames of the animated gif.
 
 If your output format is not \`"gif"\`, then this parameter does not have any effect.
+`),
+    stack: z
+        .enum(['ghostscript', 'vips', 'pdfium'])
+        .optional()
+        .describe(`
+Selects the PDF rendering stack. Defaults to Ghostscript.
+
+Use \`"pdfium"\` for page-specific or single-page high-DPI PDF rasterization when Ghostscript is too slow or exhausts scratch space, for example with high-resolution CAD, blueprint, or layered real-estate PDFs. This stack uses PDFium via the Python \`pypdfium2\` bindings and Pillow for final image encoding.
+
+Use \`"vips"\` only when you explicitly want libvips PDF loading. It is lower-overhead, but PDFium was faster in high-DPI floorplan tests while producing comparable output quality.
+
+The \`"pdfium"\` stack currently supports JPG/PNG output, \`resize_strategy: "fit"\`, a specific \`page\` or single-page PDFs, opaque hexadecimal backgrounds, \`antialiasing\`, and \`pdf_use_cropbox\`.
+
+The \`"vips"\` stack currently supports JPG/PNG output, \`resize_strategy: "fit"\`, a specific \`page\` or single-page PDFs, and hexadecimal or transparent backgrounds.
 `),
     width: z
         .number()
@@ -158,11 +185,17 @@ Some PDF documents lie about their dimensions. For instance they'll say they are
         .boolean()
         .default(true)
         .describe(`
-If you set this to \`false\`, the robot will not emit files as they become available. This is useful if you are only interested in the final result and not in the intermediate steps.
+Enables high-performance mode for faster document processing.
 
-Also, extracted pages will be resized a lot faster as they are sent off to other machines for the resizing. This is especially useful for large documents with many pages to get up to 20 times faster processing.
+When enabled, Turbo Mode provides two key optimizations:
 
-Turbo Mode increases pricing, though, in that the input document's file size is added for every extracted page. There are no performance benefits nor increased charges for single-page documents.
+1. **Parallel page extraction**: For documents with more than 5 pages, multiple processes run in parallel to extract pages simultaneously. The number of parallel processes scales with the document size (up to 4 processes for documents with 13+ pages).
+
+2. **Distributed resizing**: Extracted pages are resized concurrently on multiple machines, providing up to 20 times faster processing for large documents.
+
+Files are emitted as they become available during processing. If you set this to \`false\`, pages are extracted sequentially using a single process, and files are emitted only after all processing is complete.
+
+Turbo Mode increases pricing in that the input document's file size is added for every extracted page. There are no performance benefits nor increased charges for single-page documents.
 `),
 })
     .strict();
@@ -171,10 +204,10 @@ export const robotDocumentThumbsInstructionsWithHiddenFieldsSchema = robotDocume
         .union([z.literal('debug'), robotDocumentThumbsInstructionsSchema.shape.result])
         .optional(),
     stack: z
-        .string()
+        .enum(['ghostscript', 'vips', 'pdfium', 'imagemagick'])
         .optional()
         .describe(`
-The image processing stack to use. Defaults to the robot's preferred stack (ImageMagick).
+Selects the PDF rendering stack. Use \`"ghostscript"\` for the default renderer, \`"pdfium"\` for high-end CAD, blueprint, floorplan, or other complex high-DPI PDFs where Ghostscript is too slow or exhausts scratch space, and \`"vips"\` only when libvips PDF loading is explicitly needed. The \`"imagemagick"\` value is kept for internal/backwards-compatible use and should not be used in new public templates.
 `),
     // Override to support lowercase for BC:
     alpha: z

package/dist/v4/robots/dropbox-import.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 robotDropboxImportInstructionsSchema: 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<{
@@ -19,6 +26,13 @@ export declare const robotDropboxImportInstructionsSchema: z.ZodObject<{
     path: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
 }, z.core.$strict>;
 export declare const robotDropboxImportInstructionsWithHiddenFieldsSchema: 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";
@@ -39,6 +53,13 @@ export declare const robotDropboxImportInstructionsWithHiddenFieldsSchema: z.Zod
 export type RobotDropboxImportInstructions = z.infer<typeof robotDropboxImportInstructionsSchema>;
 export type RobotDropboxImportInstructionsWithHiddenFields = z.infer<typeof robotDropboxImportInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDropboxImportInstructionsSchema: 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<{
@@ -58,6 +79,13 @@ export declare const interpolatableRobotDropboxImportInstructionsSchema: z.ZodOb
 export type InterpolatableRobotDropboxImportInstructions = InterpolatableRobotDropboxImportInstructionsInput;
 export type InterpolatableRobotDropboxImportInstructionsInput = z.input<typeof interpolatableRobotDropboxImportInstructionsSchema>;
 export declare const interpolatableRobotDropboxImportInstructionsWithHiddenFieldsSchema: 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/dropbox-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dropbox-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/dropbox-import.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,oCAAoC;;;;;;;;;;;;;;;;kBAetC,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":"dropbox-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/dropbox-import.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,cAqClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;kBAetC,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/dropbox-import.js

@@ -1,7 +1,6 @@
 import { z } from 'zod/v4';
 import { dropboxBase, interpolateRobot, path, robotBase, robotImport, } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: true,
     bytescount: 10,
     discount_factor: 0.1,
     discount_pct: 90,