@transloadit/zod 4.2.0 → 4.3.1

package/dist/v3/robots/dropbox-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dropbox-store.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/dropbox-store.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,cAqClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AACpG,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}
+{"version":3,"file":"dropbox-store.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/dropbox-store.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,cAoClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AACpG,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}

package/dist/v3/robots/dropbox-store.js

@@ -1,7 +1,6 @@
 import { z } from 'zod/v3';
 import { dropboxBase, interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: true,
     bytescount: 6,
     discount_factor: 0.15000150001500018,
     discount_pct: 84.99984999849998,

package/dist/v3/robots/edgly-deliver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edgly-deliver.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/edgly-deliver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAC1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cA4BlB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;EAMrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;EAK5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;EAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;EAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}
+{"version":3,"file":"edgly-deliver.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/edgly-deliver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAC1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAmClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;EAMrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;EAK5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;EAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;EAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}

package/dist/v3/robots/edgly-deliver.js

@@ -1,10 +1,17 @@
 import { z } from 'zod/v3';
 import { interpolateRobot, robotBase } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: false,
     bytescount: 20,
     discount_factor: 0.05,
     discount_pct: 95,
+    example_code: {
+        steps: {
+            deliver: {
+                robot: '/edgly/deliver',
+            },
+        },
+    },
+    example_code_description: 'Cache and deliver files over Smart CDN using the edgly.net domain:',
     minimum_charge: 102400,
     output_factor: 1,
     override_lvl1: 'Content Delivery',

package/dist/v3/robots/file-compress.d.ts

@@ -64,6 +64,7 @@ export declare const robotFileCompressInstructionsSchema: z.ZodObject<{
     compression_level: z.ZodDefault<z.ZodNumber>;
     file_layout: z.ZodDefault<z.ZodEnum<["advanced", "simple", "relative-path"]>>;
     archive_name: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     robot: "/file/compress";
     result: boolean;
@@ -74,6 +75,7 @@ export declare const robotFileCompressInstructionsSchema: z.ZodObject<{
     gzip: boolean;
     compression_level: number;
     file_layout: "advanced" | "simple" | "relative-path";
+    path?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -93,6 +95,7 @@ export declare const robotFileCompressInstructionsSchema: z.ZodObject<{
     archive_name?: string | undefined;
 }, {
     robot: "/file/compress";
+    path?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -179,6 +182,7 @@ export declare const robotFileCompressInstructionsWithHiddenFieldsSchema: z.ZodO
     compression_level: z.ZodDefault<z.ZodNumber>;
     file_layout: z.ZodDefault<z.ZodEnum<["advanced", "simple", "relative-path"]>>;
     archive_name: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
 } & {
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
@@ -190,6 +194,7 @@ export declare const robotFileCompressInstructionsWithHiddenFieldsSchema: z.ZodO
     gzip: boolean;
     compression_level: number;
     file_layout: "advanced" | "simple" | "relative-path";
+    path?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -210,6 +215,7 @@ export declare const robotFileCompressInstructionsWithHiddenFieldsSchema: z.ZodO
     archive_name?: string | undefined;
 }, {
     robot: "/file/compress";
+    path?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -299,6 +305,7 @@ export declare const interpolatableRobotFileCompressInstructionsSchema: z.ZodObj
     compression_level: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     file_layout: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["advanced", "simple", "relative-path"]>]>>;
     archive_name: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     robot: "/file/compress";
     result: string | boolean;
@@ -309,6 +316,7 @@ export declare const interpolatableRobotFileCompressInstructionsSchema: z.ZodObj
     gzip: string | boolean;
     compression_level: string | number;
     file_layout: string;
+    path?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -328,6 +336,7 @@ export declare const interpolatableRobotFileCompressInstructionsSchema: z.ZodObj
     archive_name?: string | undefined;
 }, {
     robot: "/file/compress";
+    path?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -416,6 +425,7 @@ export declare const interpolatableRobotFileCompressInstructionsWithHiddenFields
     compression_level: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     file_layout: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["advanced", "simple", "relative-path"]>]>>;
     archive_name: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<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: "/file/compress";
@@ -426,6 +436,7 @@ export declare const interpolatableRobotFileCompressInstructionsWithHiddenFields
     gzip: string | boolean;
     compression_level: string | number;
     file_layout: string;
+    path?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -446,6 +457,7 @@ export declare const interpolatableRobotFileCompressInstructionsWithHiddenFields
     archive_name?: string | undefined;
 }, {
     robot: "/file/compress";
+    path?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

package/dist/v3/robots/file-compress.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-compress.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-compress.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,cA0ElB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}
+{"version":3,"file":"file-compress.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-compress.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,cAyElB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6DrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}

package/dist/v3/robots/file-compress.js

@@ -1,7 +1,6 @@
 import { z } from 'zod/v3';
 import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: false,
     bytescount: 1,
     discount_factor: 1,
     discount_pct: 0,
@@ -126,6 +125,14 @@ Files with same names are numbered in the \`"simple"\` file layout to avoid nami
         .optional()
         .describe(`
 The name of the archive file to be created (without the file extension).
+`),
+    path: z
+        .string()
+        .optional()
+        .describe(`
+The path at which each file is to be placed inside the archive. This may include any available [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables). Variables are evaluated per file, allowing templates like \`"\${file.meta.archive_directory}/\${file.name}"\` to preserve the original directory structure from a previously extracted archive.
+
+When this parameter is set, the \`file_layout\` parameter is ignored.
 `),
 })
     .strict();

package/dist/v3/robots/file-decompress.d.ts

@@ -56,12 +56,15 @@ export declare const robotFileDecompressInstructionsSchema: z.ZodObject<{
     }>]>>;
 } & {
     robot: z.ZodLiteral<"/file/decompress">;
+    password: z.ZodOptional<z.ZodString>;
     ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, ("meta" | "execute")[], boolean | ("meta" | "execute")[]>>;
+    turbo: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     robot: "/file/decompress";
     result: boolean;
     force_accept: boolean;
     ignore_errors: ("meta" | "execute")[];
+    turbo: boolean;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -78,6 +81,7 @@ export declare const robotFileDecompressInstructionsSchema: z.ZodObject<{
     } | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
+    password?: string | undefined;
 }, {
     robot: "/file/decompress";
     use?: string | string[] | {
@@ -99,6 +103,8 @@ export declare const robotFileDecompressInstructionsSchema: z.ZodObject<{
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
+    password?: string | undefined;
+    turbo?: boolean | undefined;
 }>;
 export declare const robotFileDecompressInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
@@ -153,13 +159,16 @@ export declare const robotFileDecompressInstructionsWithHiddenFieldsSchema: z.Zo
         group_by_original?: boolean | undefined;
     }>]>>;
     robot: z.ZodLiteral<"/file/decompress">;
+    password: z.ZodOptional<z.ZodString>;
     ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, ("meta" | "execute")[], boolean | ("meta" | "execute")[]>>;
+    turbo: z.ZodDefault<z.ZodBoolean>;
 } & {
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/file/decompress";
     force_accept: boolean;
     ignore_errors: ("meta" | "execute")[];
+    turbo: boolean;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -177,6 +186,7 @@ export declare const robotFileDecompressInstructionsWithHiddenFieldsSchema: z.Zo
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
+    password?: string | undefined;
 }, {
     robot: "/file/decompress";
     use?: string | string[] | {
@@ -198,6 +208,8 @@ export declare const robotFileDecompressInstructionsWithHiddenFieldsSchema: z.Zo
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
+    password?: string | undefined;
+    turbo?: boolean | undefined;
 }>;
 export type RobotFileDecompressInstructions = z.infer<typeof robotFileDecompressInstructionsSchema>;
 export type RobotFileDecompressInstructionsWithHiddenFields = z.infer<typeof robotFileDecompressInstructionsWithHiddenFieldsSchema>;
@@ -255,12 +267,15 @@ export declare const interpolatableRobotFileDecompressInstructionsSchema: z.ZodO
         group_by_original?: boolean | undefined;
     }>]>>;
     robot: z.ZodLiteral<"/file/decompress">;
+    password: z.ZodOptional<z.ZodString>;
     ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, ("meta" | "execute")[], boolean | ("meta" | "execute")[]>]>>;
+    turbo: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/file/decompress";
     result: string | boolean;
     force_accept: string | boolean;
     ignore_errors: string | ("meta" | "execute")[];
+    turbo: string | boolean;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -277,6 +292,7 @@ export declare const interpolatableRobotFileDecompressInstructionsSchema: z.ZodO
     } | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     queue?: string | undefined;
+    password?: string | undefined;
 }, {
     robot: "/file/decompress";
     use?: string | string[] | {
@@ -298,6 +314,8 @@ export declare const interpolatableRobotFileDecompressInstructionsSchema: z.ZodO
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
+    password?: string | undefined;
+    turbo?: string | boolean | undefined;
 }>;
 export type InterpolatableRobotFileDecompressInstructions = InterpolatableRobotFileDecompressInstructionsInput;
 export type InterpolatableRobotFileDecompressInstructionsInput = z.input<typeof interpolatableRobotFileDecompressInstructionsSchema>;
@@ -354,12 +372,15 @@ export declare const interpolatableRobotFileDecompressInstructionsWithHiddenFiel
         group_by_original?: boolean | undefined;
     }>]>>;
     robot: z.ZodLiteral<"/file/decompress">;
+    password: z.ZodOptional<z.ZodString>;
     ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, ("meta" | "execute")[], boolean | ("meta" | "execute")[]>]>>;
+    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]>>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/file/decompress";
     force_accept: string | boolean;
     ignore_errors: string | ("meta" | "execute")[];
+    turbo: string | boolean;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -377,6 +398,7 @@ export declare const interpolatableRobotFileDecompressInstructionsWithHiddenFiel
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
     queue?: string | undefined;
+    password?: string | undefined;
 }, {
     robot: "/file/decompress";
     use?: string | string[] | {
@@ -398,6 +420,8 @@ export declare const interpolatableRobotFileDecompressInstructionsWithHiddenFiel
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
+    password?: string | undefined;
+    turbo?: string | boolean | undefined;
 }>;
 export type InterpolatableRobotFileDecompressInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFileDecompressInstructionsWithHiddenFieldsSchema>;
 export type InterpolatableRobotFileDecompressInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFileDecompressInstructionsWithHiddenFieldsSchema>;

package/dist/v3/robots/file-decompress.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-decompress.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-decompress.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,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkDvC,CAAA;AAEX,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK9D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/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":"file-decompress.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-decompress.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,cAkClB,CAAA;AAED,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4EvC,CAAA;AAEX,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK9D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/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/v3/robots/file-decompress.js

@@ -1,7 +1,6 @@
 import { z } from 'zod/v3';
 import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: true,
     bytescount: 1,
     discount_factor: 0.8,
     discount_pct: 20,
@@ -41,9 +40,9 @@ export const robotFileDecompressInstructionsSchema = robotBase
     robot: z.literal('/file/decompress').describe(`
 This Robot supports the following archive formats:
 
-- ZIP archives (with uncompressed or "deflate"-compressed entries)
-- 7-Zip archives
-- RAR archives
+- ZIP archives (with uncompressed or "deflate"-compressed entries, including password-protected)
+- 7-Zip archives (including AES-256 encrypted)
+- RAR archives (including encrypted)
 - GNU tar format (including GNU long filenames, long link names, and sparse files)
 - Solaris 9 extended tar format (including ACLs)
 - Old V7 tar archives
@@ -69,7 +68,21 @@ This <dfn>Robot</dfn> also detects and handles any of the following before evalu
 - compress/LZW compression
 - lzma, lzip, and xz compression
 
-For security reasons, archives that contain symlinks to outside the archived dir, will error out the <dfn>Assembly</dfn>. Decompressing password-protected archives (encrypted archives) is currently not fully supported but will not cause an <dfn>Assembly</dfn> to fail.
+For security reasons, archives that contain symlinks to outside the archived dir, will error out the <dfn>Assembly</dfn>.
+
+Password-protected archives (ZIP with ZipCrypto or AES encryption, RAR encrypted, 7z with AES-256) are supported via the \`password\` parameter.
+`),
+    password: z
+        .string()
+        .optional()
+        .describe(`
+The password to use for decrypting password-protected archives.
+
+Supports encrypted ZIP (ZipCrypto and AES), RAR (encrypted), and 7z (AES-256 encrypted) archives.
+
+For security, this value should be passed via Template Variables (\`\${fields.archive_password}\`) or Template Credentials rather than hardcoded in your Assembly Instructions. The password is never logged or included in Assembly status responses.
+
+If the archive is encrypted and no password is provided, or if the password is incorrect, the <dfn>Assembly</dfn> will fail with a \`FILE_DECOMPRESS_PASSWORD_REQUIRED\` or \`FILE_DECOMPRESS_PASSWORD_INCORRECT\` error.
 `),
     ignore_errors: z
         .union([z.boolean(), z.array(z.enum(['meta', 'execute']))])
@@ -81,6 +94,18 @@ A possible array member is only \`"meta"\`.
 You might see an error when trying to extract metadata from the files inside your archive. This happens, for example, for files with a size of zero bytes. Setting this to \`true\` will cause the <dfn>Robot</dfn> to not stop the file decompression (and the entire <dfn>Assembly</dfn>) when that happens.
 
 To keep backwards compatibility, setting this parameter to \`true\` will set it to \`["meta"]\` internally.
+`),
+    turbo: z
+        .boolean()
+        .default(true)
+        .describe(`
+Enables Turbo Mode for \`/file/decompress\`.
+
+This setting defaults to \`true\`. Set it to \`false\` to disable Turbo Mode.
+
+When enabled, extracted files are emitted as soon as they are available, which can speed up downstream processing for large archives.
+
+Turbo Mode also changes usage accounting: emitted extracted-file bytes and original input-archive bytes are billed with a surcharge (25% by default).
 `),
 })
     .strict();

package/dist/v3/robots/file-filter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-filter.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-filter.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,cAuClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2FnC,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":"file-filter.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-filter.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,cAsClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6GnC,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/file-filter.js

@@ -1,7 +1,6 @@
 import { z } from 'zod/v3';
 import { filterCondition, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: true,
     bytescount: 0,
     discount_factor: 0,
     discount_pct: 100,
@@ -10,7 +9,7 @@ export const meta = {
             filtered: {
                 robot: '/file/filter',
                 use: ':original',
-                declines: [['${file.size}', '>', '20971520']],
+                declines: [['${file.size}', '>', '20mb']],
                 error_on_decline: true,
                 error_msg: 'File size must not exceed 20 MB',
             },
@@ -65,9 +64,21 @@ Examples:
 
 - \`[["\${file.meta.width}", ">", "\${file.meta.height}"]]\`
 - \`[["\${file.size}", "<=", "720"]]\`
+- \`[["\${file.size}", ">", "20mb"]]\`
 - \`[["720", ">=", "\${file.size}"]]\`
 - \`[["\${file.mime}", "regex", "image"]]\`
 
+When you match against \`\${file.mime}\`, the value is typically based on Transloadit’s
+server-side metadata extraction in the normal upload flow, rather than only the MIME type reported
+by the client or browser. This makes \`/file/filter\` suitable for rejecting mislabeled files.
+Depending on the file container and the detection tools involved, some formats may be reported under
+closely related MIME types such as \`image/heic\` or \`image/heif\`.
+
+If you only want formats that browsers consistently render, prefer an explicit allowlist such as
+\`^(image/jpeg|image/png|image/gif|image/webp|image/avif)$\` over a broad \`^image/\` rule.
+
+For numeric comparisons (\`<\`, \`>\`, \`<=\`, \`>=\`), you can use human-readable byte values such as \`"20mb"\`, \`"1gb"\`, or \`"512kb"\`. These use binary (1024-based) multipliers. Supported units: \`b\`, \`kb\`, \`mb\`, \`gb\`, \`tb\`, \`pb\` (and their IEC equivalents \`kib\`, \`mib\`, \`gib\`, \`tib\`, \`pib\`).
+
 The \`includes\` and \`!includes\` operators work with arrays or strings (strings use substring checks).
 
 > [!Warning]
@@ -88,9 +99,12 @@ As indicated, we charge for this via [🤖/script/run](/docs/robots/script-run/)
 `),
     accepts: filterCondition
         .describe(`
-Files that match at least one requirement will be accepted, or declined otherwise. If the value is \`null\`, all files will be accepted. If the array is empty, no files will be accepted. Example:
+Files that match at least one requirement will be accepted, or declined otherwise. If the value is \`null\`, all files will be accepted. If the array is empty, no files will be accepted. Examples:
 
-\`[["\${file.mime}", "==", "image/gif"]]\`.
+\`[["\${file.mime}", "==", "image/gif"]]\`
+\`[["\${file.size}", "<", "5kb"]]\`
+
+For numeric comparisons (\`<\`, \`>\`, \`<=\`, \`>=\`), human-readable byte values such as \`"20mb"\`, \`"1gb"\`, or \`"512kb"\` are supported.
 
 If the \`condition_type\` parameter is set to \`"and"\`, then all requirements must match for the file to be accepted.
 
@@ -99,9 +113,12 @@ If \`accepts\` and \`declines\` are both provided, the requirements in \`accepts
         .optional(),
     declines: filterCondition
         .describe(`
-Files that match at least one requirement will be declined, or accepted otherwise. If the value is \`null\` or an empty array, no files will be declined. Example:
+Files that match at least one requirement will be declined, or accepted otherwise. If the value is \`null\` or an empty array, no files will be declined. Examples:
+
+\`[["\${file.size}", ">", "1024"]]\`
+\`[["\${file.size}", ">", "20mb"]]\`
 
-\`[["\${file.size}",">","1024"]]\`.
+For numeric comparisons (\`<\`, \`>\`, \`<=\`, \`>=\`), human-readable byte values such as \`"20mb"\`, \`"1gb"\`, or \`"512kb"\` are supported.
 
 If the \`condition_type\` parameter is set to \`"and"\`, then all requirements must match for the file to be declined.
 

package/dist/v3/robots/file-hash.d.ts

@@ -59,12 +59,16 @@ export declare const robotFileHashInstructionsSchema: z.ZodObject<{
 } & {
     robot: z.ZodLiteral<"/file/hash">;
     algorithm: z.ZodDefault<z.ZodEnum<["b2", "md5", "sha1", "sha224", "sha256", "sha384", "sha512"]>>;
+    partial: z.ZodDefault<z.ZodEnum<["full", "first", "last", "both"]>>;
+    partial_size: z.ZodDefault<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
+    partial: "full" | "last" | "first" | "both";
     robot: "/file/hash";
     result: boolean;
     force_accept: boolean;
     ignore_errors: string[];
     algorithm: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512";
+    partial_size: number;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -83,6 +87,7 @@ export declare const robotFileHashInstructionsSchema: z.ZodObject<{
     queue?: "batch" | undefined;
 }, {
     robot: "/file/hash";
+    partial?: "full" | "last" | "first" | "both" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -103,6 +108,7 @@ export declare const robotFileHashInstructionsSchema: z.ZodObject<{
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
     algorithm?: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512" | undefined;
+    partial_size?: number | undefined;
 }>;
 export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
@@ -159,13 +165,17 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
     }>]>>;
     robot: z.ZodLiteral<"/file/hash">;
     algorithm: z.ZodDefault<z.ZodEnum<["b2", "md5", "sha1", "sha224", "sha256", "sha384", "sha512"]>>;
+    partial: z.ZodDefault<z.ZodEnum<["full", "first", "last", "both"]>>;
+    partial_size: z.ZodDefault<z.ZodNumber>;
 } & {
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
+    partial: "full" | "last" | "first" | "both";
     robot: "/file/hash";
     force_accept: boolean;
     ignore_errors: string[];
     algorithm: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512";
+    partial_size: number;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -185,6 +195,7 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
     queue?: "batch" | undefined;
 }, {
     robot: "/file/hash";
+    partial?: "full" | "last" | "first" | "both" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -205,6 +216,7 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
     algorithm?: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512" | undefined;
+    partial_size?: number | undefined;
 }>;
 export type RobotFileHashInstructions = z.infer<typeof robotFileHashInstructionsSchema>;
 export type RobotFileHashInstructionsWithHiddenFields = z.infer<typeof robotFileHashInstructionsWithHiddenFieldsSchema>;
@@ -264,12 +276,16 @@ export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<
     }>]>>;
     robot: z.ZodLiteral<"/file/hash">;
     algorithm: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["b2", "md5", "sha1", "sha224", "sha256", "sha384", "sha512"]>]>>;
+    partial: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["full", "first", "last", "both"]>]>>;
+    partial_size: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
 }, "strict", z.ZodTypeAny, {
+    partial: string;
     robot: "/file/hash";
     result: string | boolean;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     algorithm: string;
+    partial_size: string | number;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -288,6 +304,7 @@ export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<
     queue?: string | undefined;
 }, {
     robot: "/file/hash";
+    partial?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -308,6 +325,7 @@ export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
     algorithm?: string | undefined;
+    partial_size?: string | number | undefined;
 }>;
 export type InterpolatableRobotFileHashInstructions = InterpolatableRobotFileHashInstructionsInput;
 export type InterpolatableRobotFileHashInstructionsInput = z.input<typeof interpolatableRobotFileHashInstructionsSchema>;
@@ -366,12 +384,16 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
     }>]>>;
     robot: z.ZodLiteral<"/file/hash">;
     algorithm: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["b2", "md5", "sha1", "sha224", "sha256", "sha384", "sha512"]>]>>;
+    partial: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["full", "first", "last", "both"]>]>>;
+    partial_size: 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]>>]>>;
 }, "strict", z.ZodTypeAny, {
+    partial: string;
     robot: "/file/hash";
     force_accept: string | boolean;
     ignore_errors: string | string[];
     algorithm: string;
+    partial_size: string | number;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -391,6 +413,7 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
     queue?: string | undefined;
 }, {
     robot: "/file/hash";
+    partial?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -411,6 +434,7 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
     algorithm?: string | undefined;
+    partial_size?: string | number | undefined;
 }>;
 export type InterpolatableRobotFileHashInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFileHashInstructionsWithHiddenFieldsSchema>;
 export type InterpolatableRobotFileHashInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFileHashInstructionsWithHiddenFieldsSchema>;

package/dist/v3/robots/file-hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-hash.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-hash.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,cAkClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAejC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,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":"file-hash.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-hash.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,cAiClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsCjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,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/v3/robots/file-hash.js

@@ -1,7 +1,6 @@
 import { z } from 'zod/v3';
 import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: false,
     bytescount: 5,
     discount_factor: 0.2,
     discount_pct: 80,
@@ -48,6 +47,29 @@ This <dfn>Robot</dfn> allows you to hash any file as part of the <dfn>Assembly</
 The hashing algorithm to use.
 
 The file hash is exported as \`file.meta.hash\`.
+`),
+    partial: z
+        .enum(['full', 'first', 'last', 'both'])
+        .default('full')
+        .describe(`
+Specifies which portion of the file to hash. This is useful for fast fingerprinting of large files.
+
+- \`"full"\` (default): Hash the entire file.
+- \`"first"\`: Hash only the first N bytes (specified by \`partial_size\`).
+- \`"last"\`: Hash only the last N bytes (specified by \`partial_size\`).
+- \`"both"\`: Hash the first N bytes concatenated with the last N bytes.
+
+When using partial hashing, \`file.meta.hash_partial\` indicates the mode used, and \`file.meta.hash_partial_size\` indicates the number of bytes hashed from each portion.
+`),
+    partial_size: z
+        .number()
+        .int()
+        .positive()
+        .default(1048576)
+        .describe(`
+The number of bytes to hash when using partial hashing. Defaults to \`1048576\` (1 MB).
+
+This parameter is only used when \`partial\` is set to \`"first"\`, \`"last"\`, or \`"both"\`.
 `),
 })
     .strict();