@transloadit/zod 4.3.0 → 4.3.2

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

@@ -2,6 +2,7 @@ import { z } from 'zod/v3';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotFileDecompressInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
@@ -56,12 +57,16 @@ 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;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -78,8 +83,10 @@ export declare const robotFileDecompressInstructionsSchema: z.ZodObject<{
     } | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
+    password?: string | undefined;
 }, {
     robot: "/file/decompress";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -99,8 +106,11 @@ 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<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -153,13 +163,17 @@ 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;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -177,8 +191,10 @@ 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";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -198,10 +214,13 @@ 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>;
 export declare const interpolatableRobotFileDecompressInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     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, "many">]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
@@ -255,12 +274,16 @@ 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;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -277,8 +300,10 @@ 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";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -298,10 +323,13 @@ 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>;
 export declare const interpolatableRobotFileDecompressInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     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, "many">]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -354,12 +382,16 @@ 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;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -377,8 +409,10 @@ 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";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -398,6 +432,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

@@ -2,6 +2,7 @@ import { z } from 'zod/v3';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotFileFilterInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
@@ -71,6 +72,7 @@ export declare const robotFileFilterInstructionsSchema: z.ZodObject<{
     condition_type: "or" | "and";
     error_on_decline: boolean;
     error_msg: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -91,6 +93,7 @@ export declare const robotFileFilterInstructionsSchema: z.ZodObject<{
     declines?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "<" | "=" | ">" | "empty" | "==" | "===" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
 }, {
     robot: "/file/filter";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -117,6 +120,7 @@ export declare const robotFileFilterInstructionsSchema: z.ZodObject<{
     error_msg?: string | undefined;
 }>;
 export declare const robotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -184,6 +188,7 @@ export declare const robotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObj
     condition_type: "or" | "and";
     error_on_decline: boolean;
     error_msg: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -205,6 +210,7 @@ export declare const robotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObj
     declines?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "<" | "=" | ">" | "empty" | "==" | "===" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
 }, {
     robot: "/file/filter";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -233,6 +239,7 @@ export declare const robotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObj
 export type RobotFileFilterInstructions = z.infer<typeof robotFileFilterInstructionsSchema>;
 export type RobotFileFilterInstructionsWithHiddenFields = z.infer<typeof robotFileFilterInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotFileFilterInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     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, "many">]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
@@ -300,6 +307,7 @@ export declare const interpolatableRobotFileFilterInstructionsSchema: z.ZodObjec
     condition_type: string;
     error_on_decline: string | boolean;
     error_msg: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -320,6 +328,7 @@ export declare const interpolatableRobotFileFilterInstructionsSchema: z.ZodObjec
     declines?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
 }, {
     robot: "/file/filter";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -348,6 +357,7 @@ export declare const interpolatableRobotFileFilterInstructionsSchema: z.ZodObjec
 export type InterpolatableRobotFileFilterInstructions = InterpolatableRobotFileFilterInstructionsInput;
 export type InterpolatableRobotFileFilterInstructionsInput = z.input<typeof interpolatableRobotFileFilterInstructionsSchema>;
 export declare const interpolatableRobotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     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, "many">]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -414,6 +424,7 @@ export declare const interpolatableRobotFileFilterInstructionsWithHiddenFieldsSc
     condition_type: string;
     error_on_decline: string | boolean;
     error_msg: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -435,6 +446,7 @@ export declare const interpolatableRobotFileFilterInstructionsWithHiddenFieldsSc
     declines?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
 }, {
     robot: "/file/filter";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHnC,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',
             },
@@ -51,6 +50,10 @@ The <dfn>Robot</dfn> has two modes of operation:
 - Constructing conditions out of arrays with 3 members each. For example, \`["\${file.size}", "<=", "720"]\`
 - Writing conditions in JavaScript. For example, \`\${file.size <= 720}\`. See also [Dynamic Evaluation](/docs/topics/dynamic-evaluation/).
 
+If you want a \`/file/filter\` Step to pass every input file through unchanged, leave \`accepts\` and
+\`declines\` unset, or set them to \`null\`. Do not use \`"accepts": "true"\` for this: plain strings
+are treated as JavaScript expressions only when they use the \`\${...}\` form, such as \`"\${true}"\`.
+
 Passing JavaScript allows you to implement logic as complex as you wish, however it’s slower than combining arrays of conditions, and will be charged for per invocation via [🤖/script/run](/docs/robots/script-run/).
 
 ### Conditions as arrays
@@ -65,9 +68,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 +103,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. Omit this parameter or set it to \`null\` when you want the Step to pass every file through. Examples:
+
+\`[["\${file.mime}", "==", "image/gif"]]\`
+\`[["\${file.size}", "<", "5kb"]]\`
 
-\`[["\${file.mime}", "==", "image/gif"]]\`.
+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 +117,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

@@ -2,6 +2,7 @@ import { z } from 'zod/v3';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotFileHashInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
@@ -59,12 +60,17 @@ 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;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -83,6 +89,8 @@ export declare const robotFileHashInstructionsSchema: z.ZodObject<{
     queue?: "batch" | undefined;
 }, {
     robot: "/file/hash";
+    partial?: "full" | "last" | "first" | "both" | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -103,8 +111,10 @@ 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<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -159,13 +169,18 @@ 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;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -185,6 +200,8 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
     queue?: "batch" | undefined;
 }, {
     robot: "/file/hash";
+    partial?: "full" | "last" | "first" | "both" | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -205,10 +222,12 @@ 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>;
 export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     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, "many">]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
@@ -264,12 +283,17 @@ 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;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -288,6 +312,8 @@ export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<
     queue?: string | undefined;
 }, {
     robot: "/file/hash";
+    partial?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -308,10 +334,12 @@ 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>;
 export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     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, "many">]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -366,12 +394,17 @@ 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;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -391,6 +424,8 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
     queue?: string | undefined;
 }, {
     robot: "/file/hash";
+    partial?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -411,6 +446,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();