@transloadit/zod 4.3.0 → 4.3.2

package/dist/v4/robots/audio-split.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-split.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/audio-split.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAG1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAUnE,eAAO,MAAM,IAAI,EAAE,cAyClB,CAAA;AAiBD,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0BnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}

package/dist/v4/robots/audio-split.js

@@ -0,0 +1,87 @@
+import { z } from 'zod/v4';
+import { stackVersions } from "../stackVersions.js";
+import { bitrateSchema, interpolateRobot, robotBase, robotFFmpegAudio, robotUse, sampleRateSchema, } from "./_instructions-primitives.js";
+export const meta = {
+    bytescount: 4,
+    discount_factor: 0.25,
+    discount_pct: 75,
+    example_code: {
+        steps: {
+            split: {
+                robot: '/audio/split',
+                use: ':original',
+                ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
+                segments: [
+                    { from: 0, to: 30 },
+                    { from: 60, to: 90 },
+                ],
+            },
+        },
+    },
+    example_code_description: 'Split an audio file into two segments, extracting the first 30 seconds and a segment from 1:00 to 1:30:',
+    minimum_charge: 0,
+    output_factor: 0.8,
+    override_lvl1: 'Audio Encoding',
+    purpose_sentence: 'splits an audio file into multiple segments based on an array of from/to durations',
+    purpose_verb: 'split',
+    purpose_word: 'split',
+    purpose_words: 'Split audio',
+    service_slug: 'audio-encoding',
+    slot_count: 20,
+    title: 'Split audio',
+    typical_file_size_mb: 3.8,
+    typical_file_type: 'audio file',
+    uses_tools: ['ffmpeg'],
+    name: 'AudioSplitRobot',
+    priceFactor: 4,
+    queueSlotCount: 20,
+    isAllowedForUrlTransform: true,
+    trackOutputFileSize: true,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+    stage: 'ga',
+};
+const segmentSchema = z
+    .object({
+    from: z
+        .union([z.number(), z.string()])
+        .describe('Start time of the segment in seconds (e.g. `30`) or as a timecode string (e.g. `"00:00:30.000"`).'),
+    to: z
+        .union([z.number(), z.string()])
+        .describe('End time of the segment in seconds (e.g. `60`) or as a timecode string (e.g. `"00:01:00.000"`).'),
+})
+    .strict();
+export const robotAudioSplitInstructionsSchema = robotBase
+    .merge(robotUse)
+    .merge(robotFFmpegAudio)
+    .extend({
+    result: z
+        .boolean()
+        .optional()
+        .describe('Whether the results of this Step should be present in the Assembly Status JSON'),
+    robot: z.literal('/audio/split').describe(`
+Splits an audio file into multiple segments based on an array of from/to durations. Each segment produces a separate output file. This is useful for cutting an audio file into parts, for example to insert ads later via [🤖/audio/concat](/docs/robots/audio-concat/).
+`),
+    segments: z
+        .array(segmentSchema)
+        .min(1)
+        .describe(`
+An array of objects, each specifying a segment to extract from the input audio. Each object must have a \`from\` and \`to\` key indicating the start and end time of the segment.
+
+Times can be specified as numbers (seconds) or as timecode strings (e.g. \`"00:01:30.000"\`).
+`),
+    bitrate: bitrateSchema.optional().describe(`
+Bit rate of the resulting audio file, in bits per second. If not specified will default to the bit rate of the input audio file.
+`),
+    sample_rate: sampleRateSchema.optional().describe(`
+Sample rate of the resulting audio file, in Hertz. If not specified will default to the sample rate of the input audio file.
+`),
+})
+    .strict();
+export const robotAudioSplitInstructionsWithHiddenFieldsSchema = robotAudioSplitInstructionsSchema.extend({
+    result: z
+        .union([z.literal('debug'), robotAudioSplitInstructionsSchema.shape.result])
+        .optional(),
+});
+export const interpolatableRobotAudioSplitInstructionsSchema = interpolateRobot(robotAudioSplitInstructionsSchema);
+export const interpolatableRobotAudioSplitInstructionsWithHiddenFieldsSchema = interpolateRobot(robotAudioSplitInstructionsWithHiddenFieldsSchema);

package/dist/v4/robots/audio-waveform.d.ts

@@ -1,7 +1,16 @@
 import { z } from 'zod/v4';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
+export type SpectrogramColorMap = 'viridis' | 'plasma' | 'magma' | 'cividis' | 'cool' | 'rainbow' | 'moreland' | 'nebulae' | 'fire' | 'fiery' | 'fruit' | 'green' | 'terrain' | 'gray';
+export declare const spectrogramColorMaps: readonly ["viridis", "plasma", "magma", "cividis", "cool", "rainbow", "moreland", "nebulae", "fire", "fiery", "fruit", "green", "terrain", "gray"];
 export declare const robotAudioWaveformInstructionsSchema: 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<{
@@ -136,9 +145,10 @@ export declare const robotAudioWaveformInstructionsSchema: z.ZodObject<{
     background_color: z.ZodDefault<z.ZodString>;
     center_color: z.ZodDefault<z.ZodString>;
     outer_color: z.ZodDefault<z.ZodString>;
-    style: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodEnum<{
+    style: z.ZodPreprocess<z.ZodDefault<z.ZodEnum<{
         v0: "v0";
         v1: "v1";
+        spectrogram: "spectrogram";
     }>>>;
     split_channels: z.ZodOptional<z.ZodBoolean>;
     zoom: z.ZodOptional<z.ZodNumber>;
@@ -166,8 +176,43 @@ export declare const robotAudioWaveformInstructionsSchema: z.ZodObject<{
     with_axis_labels: z.ZodOptional<z.ZodBoolean>;
     amplitude_scale: z.ZodOptional<z.ZodNumber>;
     compression: z.ZodOptional<z.ZodNumber>;
+    color_map: z.ZodOptional<z.ZodEnum<{
+        green: "green";
+        gray: "gray";
+        viridis: "viridis";
+        plasma: "plasma";
+        magma: "magma";
+        cividis: "cividis";
+        cool: "cool";
+        rainbow: "rainbow";
+        moreland: "moreland";
+        nebulae: "nebulae";
+        fire: "fire";
+        fiery: "fiery";
+        fruit: "fruit";
+        terrain: "terrain";
+    }>>;
+    frequency_scale: z.ZodOptional<z.ZodEnum<{
+        linear: "linear";
+        logarithmic: "logarithmic";
+    }>>;
+    frequency_min: z.ZodOptional<z.ZodNumber>;
+    frequency_max: z.ZodOptional<z.ZodNumber>;
+    legend: z.ZodOptional<z.ZodBoolean>;
+    gain: z.ZodOptional<z.ZodNumber>;
+    orientation: z.ZodOptional<z.ZodEnum<{
+        vertical: "vertical";
+        horizontal: "horizontal";
+    }>>;
 }, z.core.$strict>;
 export declare const robotAudioWaveformInstructionsWithHiddenFieldsSchema: 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";
@@ -301,9 +346,10 @@ export declare const robotAudioWaveformInstructionsWithHiddenFieldsSchema: z.Zod
     background_color: z.ZodDefault<z.ZodString>;
     center_color: z.ZodDefault<z.ZodString>;
     outer_color: z.ZodDefault<z.ZodString>;
-    style: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodEnum<{
+    style: z.ZodPreprocess<z.ZodDefault<z.ZodEnum<{
         v0: "v0";
         v1: "v1";
+        spectrogram: "spectrogram";
     }>>>;
     split_channels: z.ZodOptional<z.ZodBoolean>;
     zoom: z.ZodOptional<z.ZodNumber>;
@@ -331,11 +377,46 @@ export declare const robotAudioWaveformInstructionsWithHiddenFieldsSchema: z.Zod
     with_axis_labels: z.ZodOptional<z.ZodBoolean>;
     amplitude_scale: z.ZodOptional<z.ZodNumber>;
     compression: z.ZodOptional<z.ZodNumber>;
+    color_map: z.ZodOptional<z.ZodEnum<{
+        green: "green";
+        gray: "gray";
+        viridis: "viridis";
+        plasma: "plasma";
+        magma: "magma";
+        cividis: "cividis";
+        cool: "cool";
+        rainbow: "rainbow";
+        moreland: "moreland";
+        nebulae: "nebulae";
+        fire: "fire";
+        fiery: "fiery";
+        fruit: "fruit";
+        terrain: "terrain";
+    }>>;
+    frequency_scale: z.ZodOptional<z.ZodEnum<{
+        linear: "linear";
+        logarithmic: "logarithmic";
+    }>>;
+    frequency_min: z.ZodOptional<z.ZodNumber>;
+    frequency_max: z.ZodOptional<z.ZodNumber>;
+    legend: z.ZodOptional<z.ZodBoolean>;
+    gain: z.ZodOptional<z.ZodNumber>;
+    orientation: z.ZodOptional<z.ZodEnum<{
+        vertical: "vertical";
+        horizontal: "horizontal";
+    }>>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, z.core.$strict>;
 export type RobotAudioWaveformInstructions = z.infer<typeof robotAudioWaveformInstructionsSchema>;
 export type RobotAudioWaveformInstructionsWithHiddenFields = z.infer<typeof robotAudioWaveformInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotAudioWaveformInstructionsSchema: 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<{
@@ -470,10 +551,11 @@ export declare const interpolatableRobotAudioWaveformInstructionsSchema: z.ZodOb
     background_color: z.ZodDefault<z.ZodString>;
     center_color: z.ZodDefault<z.ZodString>;
     outer_color: z.ZodDefault<z.ZodString>;
-    style: z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodEnum<{
+    style: z.ZodPreprocess<z.ZodDefault<z.ZodEnum<{
         v0: "v0";
         v1: "v1";
-    }>>>]>;
+        spectrogram: "spectrogram";
+    }>>>;
     split_channels: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     zoom: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     pixels_per_second: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
@@ -500,10 +582,45 @@ export declare const interpolatableRobotAudioWaveformInstructionsSchema: z.ZodOb
     with_axis_labels: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     amplitude_scale: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     compression: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    color_map: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        green: "green";
+        gray: "gray";
+        viridis: "viridis";
+        plasma: "plasma";
+        magma: "magma";
+        cividis: "cividis";
+        cool: "cool";
+        rainbow: "rainbow";
+        moreland: "moreland";
+        nebulae: "nebulae";
+        fire: "fire";
+        fiery: "fiery";
+        fruit: "fruit";
+        terrain: "terrain";
+    }>]>>;
+    frequency_scale: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        linear: "linear";
+        logarithmic: "logarithmic";
+    }>]>>;
+    frequency_min: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    frequency_max: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    legend: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    gain: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    orientation: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        vertical: "vertical";
+        horizontal: "horizontal";
+    }>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotAudioWaveformInstructions = z.input<typeof interpolatableRobotAudioWaveformInstructionsSchema>;
 export type InterpolatableRobotAudioWaveformInstructionsInput = z.input<typeof interpolatableRobotAudioWaveformInstructionsSchema>;
 export declare const interpolatableRobotAudioWaveformInstructionsWithHiddenFieldsSchema: 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";
@@ -637,10 +754,11 @@ export declare const interpolatableRobotAudioWaveformInstructionsWithHiddenField
     background_color: z.ZodDefault<z.ZodString>;
     center_color: z.ZodDefault<z.ZodString>;
     outer_color: z.ZodDefault<z.ZodString>;
-    style: z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodEnum<{
+    style: z.ZodPreprocess<z.ZodDefault<z.ZodEnum<{
         v0: "v0";
         v1: "v1";
-    }>>>]>;
+        spectrogram: "spectrogram";
+    }>>>;
     split_channels: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     zoom: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     pixels_per_second: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
@@ -667,6 +785,34 @@ export declare const interpolatableRobotAudioWaveformInstructionsWithHiddenField
     with_axis_labels: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     amplitude_scale: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     compression: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    color_map: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        green: "green";
+        gray: "gray";
+        viridis: "viridis";
+        plasma: "plasma";
+        magma: "magma";
+        cividis: "cividis";
+        cool: "cool";
+        rainbow: "rainbow";
+        moreland: "moreland";
+        nebulae: "nebulae";
+        fire: "fire";
+        fiery: "fiery";
+        fruit: "fruit";
+        terrain: "terrain";
+    }>]>>;
+    frequency_scale: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        linear: "linear";
+        logarithmic: "logarithmic";
+    }>]>>;
+    frequency_min: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    frequency_max: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    legend: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    gain: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    orientation: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        vertical: "vertical";
+        horizontal: "horizontal";
+    }>]>>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotAudioWaveformInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotAudioWaveformInstructionsWithHiddenFieldsSchema>;

package/dist/v4/robots/audio-waveform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audio-waveform.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/audio-waveform.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,cAgDlB,CAAA;AAgED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0HtC,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;AAED,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,kDAAkD,CAC1D,CAAA;AACD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,CAAA;AAED,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":"audio-waveform.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/audio-waveform.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,cA+ClB,CAAA;AAiED,MAAM,MAAM,mBAAmB,GAC3B,SAAS,GACT,QAAQ,GACR,OAAO,GACP,SAAS,GACT,MAAM,GACN,SAAS,GACT,UAAU,GACV,SAAS,GACT,MAAM,GACN,OAAO,GACP,OAAO,GACP,OAAO,GACP,SAAS,GACT,MAAM,CAAA;AAEV,eAAO,MAAM,oBAAoB,oJAekB,CAAA;AAInD,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2KtC,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;AAED,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,kDAAkD,CAC1D,CAAA;AACD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,CAAA;AAED,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/audio-waveform.js

@@ -1,7 +1,6 @@
 import { z } from 'zod/v4';
 import { color_with_alpha, interpolateRobot, robotBase, robotFFmpeg, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: false,
     bytescount: 1,
     discount_factor: 1,
     discount_pct: 0,
@@ -41,7 +40,7 @@ Here is an example waveform image:
     priceFactor: 1,
     queueSlotCount: 20,
     minimumCharge: 1048576,
-    isAllowedForUrlTransform: false,
+    isAllowedForUrlTransform: true,
     trackOutputFileSize: true,
     isInternal: false,
     removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
@@ -62,6 +61,7 @@ Similarly, if you need the output image in a different format, please pipe the r
         .default('image')
         .describe(`
 The format of the result file. Can be \`"image"\` or \`"json"\`. If \`"image"\` is supplied, a PNG image will be created, otherwise a JSON file.
+When \`style\` is \`"spectrogram"\`, only \`"image"\` is supported.
 `),
     width: z
         .number()
@@ -96,14 +96,32 @@ The color used in the outer parts of the gradient. The format is "rrggbbaa" (red
 `),
 });
 const styleSchema = z.preprocess((val) => {
-    // Backwards compatibility: historically this robot used numeric styles 0/1/2.
-    // The new API is `style: "v0" | "v1"`. Old v2 values are mapped to v1.
+    // Backwards compatibility: historically this robot used numeric styles 0/1.
+    // The new API is `style: "v0" | "v1" | "spectrogram"`.
     if (val === 'v1' || val === 1 || val === '1')
         return 'v1';
     if (val === 'v0' || val === 0 || val === '0')
         return 'v0';
+    if (val === 'spectrogram')
+        return 'spectrogram';
     return val;
-}, z.enum(['v0', 'v1']).default('v0'));
+}, z.enum(['v0', 'v1', 'spectrogram']).default('v0'));
+export const spectrogramColorMaps = [
+    'viridis',
+    'plasma',
+    'magma',
+    'cividis',
+    'cool',
+    'rainbow',
+    'moreland',
+    'nebulae',
+    'fire',
+    'fiery',
+    'fruit',
+    'green',
+    'terrain',
+    'gray',
+];
 // Unified schema: all parameters exist for both styles, but v1-only parameters only apply when
 // `style` is `v1` (they are accepted for v0 but have no effect).
 export const robotAudioWaveformInstructionsSchema = robotAudioWaveformInstructionsBaseSchema
@@ -113,8 +131,9 @@ Waveform style version.
 
 - \`"v0"\`: Legacy waveform generation (default).
 - \`"v1"\`: Advanced waveform generation with additional parameters.
+- \`"spectrogram"\`: Spectrogram visualization showing frequency content over time.
 
-For backwards compatibility, numeric values \`0\`, \`1\`, \`2\` are also accepted and mapped to \`"v0"\` (0) and \`"v1"\` (1/2).
+For backwards compatibility, numeric values \`0\` and \`1\` are also accepted and mapped to \`"v0"\` and \`"v1"\`.
 `),
     // v1-only parameters (accepted for v0 but have no effect)
     split_channels: z
@@ -225,6 +244,53 @@ Available when style is \`"v1"\`. Amplitude scale factor.
         .optional()
         .describe(`
 Available when style is \`"v1"\`. PNG compression level: 0 (none) to 9 (best), or -1 (default). Only applicable when format is "image".
+`),
+    // Spectrogram-specific parameters (only apply when style is "spectrogram")
+    color_map: z
+        .enum(spectrogramColorMaps)
+        .optional()
+        .describe(`
+Available when style is \`"spectrogram"\`. Color scheme for the spectrogram visualization. Defaults to \`"viridis"\`.
+`),
+    frequency_scale: z
+        .enum(['linear', 'logarithmic'])
+        .optional()
+        .describe(`
+Available when style is \`"spectrogram"\`. Frequency scale for the spectrogram. \`"linear"\` shows frequencies evenly spaced, \`"logarithmic"\` emphasizes lower frequencies. Defaults to \`"logarithmic"\`.
+`),
+    frequency_min: z
+        .number()
+        .min(0)
+        .optional()
+        .describe(`
+Available when style is \`"spectrogram"\`. Minimum frequency in Hz to display. Defaults to \`0\`.
+`),
+    frequency_max: z
+        .number()
+        .min(1)
+        .optional()
+        .describe(`
+Available when style is \`"spectrogram"\`. Maximum frequency in Hz to display. Defaults to half the sample rate (Nyquist frequency).
+`),
+    legend: z
+        .boolean()
+        .optional()
+        .describe(`
+Available when style is \`"spectrogram"\`. Whether to include a legend showing the frequency and time scales. Defaults to \`false\`.
+`),
+    gain: z
+        .number()
+        .min(0)
+        .max(128)
+        .optional()
+        .describe(`
+Available when style is \`"spectrogram"\`. Linear gain factor for spectrogram intensity. Defaults to \`1\`.
+`),
+    orientation: z
+        .enum(['vertical', 'horizontal'])
+        .optional()
+        .describe(`
+Available when style is \`"spectrogram"\`. Orientation of the spectrogram. \`"horizontal"\` shows time on the x-axis (default), \`"vertical"\` shows time on the y-axis.
 `),
 })
     .strict();

package/dist/v4/robots/azure-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 robotAzureImportInstructionsSchema: 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<{
@@ -25,6 +32,13 @@ export declare const robotAzureImportInstructionsSchema: z.ZodObject<{
     files_per_page: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
 export declare const robotAzureImportInstructionsWithHiddenFieldsSchema: 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";
@@ -50,6 +64,13 @@ export declare const robotAzureImportInstructionsWithHiddenFieldsSchema: z.ZodOb
 export type RobotAzureImportInstructions = z.infer<typeof robotAzureImportInstructionsSchema>;
 export type RobotAzureImportInstructionsWithHiddenFields = z.infer<typeof robotAzureImportInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotAzureImportInstructionsSchema: 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<{
@@ -75,6 +96,13 @@ export declare const interpolatableRobotAzureImportInstructionsSchema: z.ZodObje
 export type InterpolatableRobotAzureImportInstructions = InterpolatableRobotAzureImportInstructionsInput;
 export type InterpolatableRobotAzureImportInstructionsInput = z.input<typeof interpolatableRobotAzureImportInstructionsSchema>;
 export declare const interpolatableRobotAzureImportInstructionsWithHiddenFieldsSchema: 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/azure-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"azure-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/azure-import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAYnE,eAAO,MAAM,IAAI,EAAE,cAsClB,CAAA;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;kBAwBpC,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":"azure-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/azure-import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAYnE,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAwBpC,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/azure-import.js

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

package/dist/v4/robots/azure-store.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 robotAzureStoreInstructionsSchema: 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<{
@@ -42,6 +49,13 @@ export declare const robotAzureStoreInstructionsSchema: z.ZodObject<{
     sas_permissions: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const robotAzureStoreInstructionsWithHiddenFieldsSchema: 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";
@@ -84,6 +98,13 @@ export declare const robotAzureStoreInstructionsWithHiddenFieldsSchema: z.ZodObj
 export type RobotAzureStoreInstructions = z.infer<typeof robotAzureStoreInstructionsSchema>;
 export type RobotAzureStoreInstructionsWithHiddenFields = z.infer<typeof robotAzureStoreInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotAzureStoreInstructionsSchema: 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<{
@@ -126,6 +147,13 @@ export declare const interpolatableRobotAzureStoreInstructionsSchema: z.ZodObjec
 export type InterpolatableRobotAzureStoreInstructions = InterpolatableRobotAzureStoreInstructionsInput;
 export type InterpolatableRobotAzureStoreInstructionsInput = z.input<typeof interpolatableRobotAzureStoreInstructionsSchema>;
 export declare const interpolatableRobotAzureStoreInstructionsWithHiddenFieldsSchema: 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/azure-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"azure-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/azure-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,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiEnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}
+{"version":3,"file":"azure-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/azure-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,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiEnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}

package/dist/v4/robots/azure-store.js

@@ -1,7 +1,6 @@
 import { z } from 'zod/v4';
 import { azureBase, 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,