@transloadit/node 4.10.2 → 4.10.4

package/src/alphalib/types/robots/_instructions-primitives.ts

@@ -300,6 +300,38 @@ type InterpolatableSchema<Schema extends z.ZodTypeAny> = Schema extends z.ZodStr
                     ? z.ZodUnion<[z.ZodString, ...InterpolatableTuple<T>]>
                     : Schema
 
+function isZodTypeAny(schema: unknown): schema is z.ZodTypeAny {
+  return schema instanceof z.ZodType
+}
+
+function toFirstPartySchema(schema: unknown): z.ZodFirstPartySchemaTypes {
+  if (!isZodTypeAny(schema)) {
+    throw new Error('Expected a Zod schema')
+  }
+  return schema as z.ZodFirstPartySchemaTypes
+}
+
+function toInterpolatableSchema<Schema extends z.ZodFirstPartySchemaTypes>(
+  schema: z.ZodTypeAny,
+): InterpolatableSchema<Schema> {
+  return schema as InterpolatableSchema<Schema>
+}
+
+function toInterpolatableRobot<Schema extends z.ZodObject<z.ZodRawShape>>(
+  schema: z.ZodTypeAny,
+): InterpolatableRobot<Schema> {
+  return schema as InterpolatableRobot<Schema>
+}
+
+function toInterpolatableUnionOptions(options: z.ZodTypeAny[]): z.ZodUnionOptions {
+  if (options.length === 0) {
+    throw new Error('Union options must not be empty')
+  }
+
+  const [head, ...tail] = options
+  return [head, ...tail]
+}
+
 export function interpolateRecursive<Schema extends z.ZodFirstPartySchemaTypes>(
   schema: Schema,
 ): InterpolatableSchema<Schema> {
@@ -307,12 +339,14 @@ export function interpolateRecursive<Schema extends z.ZodFirstPartySchemaTypes>(
 
   switch (def.typeName) {
     case z.ZodFirstPartyTypeKind.ZodBoolean:
-      return z.union([
-        interpolationSchemaFull,
-        z
-          .union([schema, booleanStringSchema])
-          .transform((value) => value === true || value === false),
-      ]) as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(
+        z.union([
+          interpolationSchemaFull,
+          z
+            .union([schema, booleanStringSchema])
+            .transform((value) => value === true || value === false),
+        ]),
+      )
     case z.ZodFirstPartyTypeKind.ZodArray: {
       let replacement = z.array(interpolateRecursive(def.type), def)
 
@@ -328,88 +362,93 @@ export function interpolateRecursive<Schema extends z.ZodFirstPartySchemaTypes>(
         replacement = replacement.min(def.minLength.value, def.minLength.message)
       }
 
-      return z.union([interpolationSchemaFull, replacement]) as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(z.union([interpolationSchemaFull, replacement]))
     }
     case z.ZodFirstPartyTypeKind.ZodDefault: {
-      const replacement = (
-        interpolateRecursive(def.innerType) as InterpolatableSchema<Schema>
+      const replacement = toInterpolatableSchema<Schema>(
+        interpolateRecursive(def.innerType),
       ).default(def.defaultValue())
 
-      return (
-        def.description ? replacement.describe(def.description) : replacement
-      ) as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(
+        def.description ? replacement.describe(def.description) : replacement,
+      )
     }
     case z.ZodFirstPartyTypeKind.ZodEffects:
     case z.ZodFirstPartyTypeKind.ZodEnum:
     case z.ZodFirstPartyTypeKind.ZodLiteral:
-      return z.union([interpolationSchemaFull, schema], def) as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(z.union([interpolationSchemaFull, schema], def))
     case z.ZodFirstPartyTypeKind.ZodNumber:
-      return z.union(
-        [
-          z
-            .string()
-            .regex(/^\d+(\.\d+)?$/)
-            .transform((value) => Number(value)),
-          interpolationSchemaFull,
-          schema,
-        ],
-        def,
-      ) as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(
+        z.union(
+          [
+            z
+              .string()
+              .regex(/^\d+(\.\d+)?$/)
+              .transform((value) => Number(value)),
+            interpolationSchemaFull,
+            schema,
+          ],
+          def,
+        ),
+      )
     case z.ZodFirstPartyTypeKind.ZodNullable:
-      return interpolateRecursive(def.innerType)
-        .nullable()
-        .describe(def.description) as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(
+        interpolateRecursive(def.innerType).nullable().describe(def.description),
+      )
     case z.ZodFirstPartyTypeKind.ZodObject: {
       const replacement = z.object(
         Object.fromEntries(
           Object.entries(def.shape()).map(([key, nested]) => [
             key,
-            interpolateRecursive(nested as z.ZodFirstPartySchemaTypes),
+            interpolateRecursive(toFirstPartySchema(nested)),
           ]),
         ),
         def,
       )
-      return z.union([
-        interpolationSchemaFull,
-        def.unknownKeys === 'strict'
-          ? replacement.strict()
-          : def.unknownKeys === 'passthrough'
-            ? replacement.passthrough()
-            : replacement,
-      ]) as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(
+        z.union([
+          interpolationSchemaFull,
+          def.unknownKeys === 'strict'
+            ? replacement.strict()
+            : def.unknownKeys === 'passthrough'
+              ? replacement.passthrough()
+              : replacement,
+        ]),
+      )
     }
     case z.ZodFirstPartyTypeKind.ZodOptional:
-      return z.optional(interpolateRecursive(def.innerType), def) as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(z.optional(interpolateRecursive(def.innerType), def))
     case z.ZodFirstPartyTypeKind.ZodRecord:
-      return z.record(
-        def.keyType,
-        interpolateRecursive(def.valueType),
-        def,
-      ) as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(z.record(def.keyType, interpolateRecursive(def.valueType), def))
     case z.ZodFirstPartyTypeKind.ZodString:
-      return z.union([interpolationSchemaPartial, schema], def) as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(z.union([interpolationSchemaPartial, schema], def))
     case z.ZodFirstPartyTypeKind.ZodTuple: {
       const tuple = z.tuple(def.items.map(interpolateRecursive), def)
 
-      return z.union([
-        interpolationSchemaFull,
-        def.rest ? tuple.rest(def.rest) : tuple,
-      ]) as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(
+        z.union([interpolationSchemaFull, def.rest ? tuple.rest(def.rest) : tuple]),
+      )
     }
     case z.ZodFirstPartyTypeKind.ZodUnion:
-      return z.union(
-        [interpolationSchemaFull, ...(def.options.map(interpolateRecursive) as z.ZodUnionOptions)],
-        def,
-      ) as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(
+        z.union(
+          [
+            interpolationSchemaFull,
+            ...toInterpolatableUnionOptions(def.options.map(interpolateRecursive)),
+          ],
+          def,
+        ),
+      )
     default:
-      return schema as InterpolatableSchema<Schema>
+      return toInterpolatableSchema(schema)
   }
 }
 
 /**
  * The robot keys specified in this array can’t be interpolated.
  */
-const uninterpolatableKeys = ['robot', 'use'] as const
+const uninterpolatableKeys = ['interpolate', 'robot', 'use'] as const
+const uninterpolatableKeySet = new Set<string>(uninterpolatableKeys)
 
 type InterpolatableRobot<Schema extends z.ZodObject<z.ZodRawShape>> =
   Schema extends z.ZodObject<infer T, infer UnknownKeys, infer Catchall>
@@ -428,27 +467,45 @@ export function interpolateRobot<Schema extends z.ZodObject<z.ZodRawShape>>(
   schema: Schema,
 ): InterpolatableRobot<Schema> {
   const def = schema._def
-  return z
-    .object(
-      Object.fromEntries(
-        Object.entries(def.shape()).map(([key, nested]) => [
-          key,
-          (uninterpolatableKeys as readonly string[]).includes(key)
-            ? nested
-            : interpolateRecursive(nested as z.ZodFirstPartySchemaTypes),
-        ]),
-      ),
-      def,
-    )
-    .strict() as InterpolatableRobot<Schema>
+  return toInterpolatableRobot(
+    z
+      .object(
+        Object.fromEntries(
+          Object.entries(def.shape()).map(([key, nested]) => [
+            key,
+            uninterpolatableKeySet.has(key)
+              ? nested
+              : interpolateRecursive(toFirstPartySchema(nested)),
+          ]),
+        ),
+        def,
+      )
+      .strict(),
+  )
 }
 
+const robotInterpolateBooleanSchema = z
+  .union([z.boolean(), booleanStringSchema])
+  .transform((value) => value === true || value === 'true')
+
+export const robotInterpolateSchema = z
+  .union([robotInterpolateBooleanSchema, z.record(robotInterpolateBooleanSchema)])
+  .describe(`
+Controls whether Assembly Variables are interpolated for individual instruction fields.
+
+By default, most Robot instruction fields interpolate Assembly Variables. Set this to \`false\` to treat every instruction field as literal text, or set an individual field path to \`false\` to treat only that field as literal text. For Robot-specific fields that are literal by default, set this to \`true\` or set that field path to \`true\` to opt back into interpolation.
+
+Use field names such as \`path\`, or dotted paths such as \`ffmpeg.vf\` for nested objects.
+`)
+
 /**
  * Fields that are shared by all Transloadit robots.
  */
 export type RobotBase = z.infer<typeof robotBase>
 export const robotBase = z
   .object({
+    interpolate: robotInterpolateSchema.optional(),
+
     output_meta: z
       .union([z.record(z.boolean()), z.boolean(), z.array(z.string())])
       .optional()
@@ -805,7 +862,7 @@ A parameter object to be passed to FFmpeg. If a preset is used, the options spec
   ffmpeg_stack: z
     // Any semver in range is allowed and normalized. The enum is used for editor completions.
     .union([z.enum(['v5', 'v6', 'v7']), z.string().regex(/^v?[567](\.\d+)?(\.\d+)?$/)])
-    .default('v5.0.0')
+    .default('v6.0.0')
     .describe(`
 Selects the FFmpeg stack version to use for encoding. These versions reflect real FFmpeg versions. We currently recommend to use "v6.0.0".
 `),

package/src/alphalib/types/robots/ai-chat.ts

@@ -214,7 +214,9 @@ export const robotAiChatInstructionsSchema = robotBase
     system_message: z
       .string()
       .optional()
-      .describe('Set the system/developer prompt, if the model allows it'),
+      .describe(
+        'Set the system/developer prompt, if the model allows it. If this prompt contains literal documentation or code examples with `${...}` syntax, set `interpolate.system_message` to `false`.',
+      ),
     reasoning_effort: z
       .enum(['xhigh', 'high', 'medium', 'low'])
       .optional()

package/src/alphalib/types/robots/assembly-savejson.ts

@@ -2,9 +2,10 @@ import { z } from 'zod'
 import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase } from './_instructions-primitives.ts'
 
-// @ts-expect-error - AssemblySavejsonRobot is not ready yet @TODO please supply missing keys
 export const meta: RobotMetaInput = {
-  name: 'AssemblySavejsonRobot',
+  bytescount: 0,
+  discount_factor: 0,
+  discount_pct: 100,
   example_code: {
     steps: {
       save_json: {
@@ -13,6 +14,19 @@ export const meta: RobotMetaInput = {
     },
   },
   example_code_description: 'Save Assembly result data as JSON:',
+  minimum_charge: 0,
+  output_factor: 1,
+  override_lvl1: 'File Exporting',
+  purpose_sentence: 'exports Assembly status data as JSON',
+  purpose_verb: 'export',
+  purpose_word: 'Assembly status',
+  purpose_words: 'Export Assembly status JSON',
+  service_slug: 'file-exporting',
+  slot_count: 5,
+  title: 'Export Assembly status JSON',
+  typical_file_size_mb: 0.1,
+  typical_file_type: 'file',
+  name: 'AssemblySavejsonRobot',
   priceFactor: 0,
   queueSlotCount: 5,
   isAllowedForUrlTransform: true,

package/src/alphalib/types/robots/document-thumbs.ts

@@ -102,6 +102,20 @@ If you specify the value \`"gif"\`, then an animated gif cycling through all pag
 If your output format is \`"gif"\` then this parameter sets the number of 100th seconds to pass before the next frame is shown in the animation. Set this to \`100\` for example to allow 1 second to pass between the frames of the animated gif.
 
 If your output format is not \`"gif"\`, then this parameter does not have any effect.
+`),
+    stack: z
+      .enum(['ghostscript', 'vips', 'pdfium'])
+      .optional()
+      .describe(`
+Selects the PDF rendering stack. Defaults to Ghostscript.
+
+Use \`"pdfium"\` for page-specific or single-page high-DPI PDF rasterization when Ghostscript is too slow or exhausts scratch space, for example with high-resolution CAD, blueprint, or layered real-estate PDFs. This stack uses PDFium via the Python \`pypdfium2\` bindings and Pillow for final image encoding.
+
+Use \`"vips"\` only when you explicitly want libvips PDF loading. It is lower-overhead, but PDFium was faster in high-DPI floorplan tests while producing comparable output quality.
+
+The \`"pdfium"\` stack currently supports JPG/PNG output, \`resize_strategy: "fit"\`, a specific \`page\` or single-page PDFs, opaque hexadecimal backgrounds, \`antialiasing\`, and \`pdf_use_cropbox\`.
+
+The \`"vips"\` stack currently supports JPG/PNG output, \`resize_strategy: "fit"\`, a specific \`page\` or single-page PDFs, and hexadecimal or transparent backgrounds.
 `),
     width: z
       .number()
@@ -206,10 +220,10 @@ export const robotDocumentThumbsInstructionsWithHiddenFieldsSchema =
       .union([z.literal('debug'), robotDocumentThumbsInstructionsSchema.shape.result])
       .optional(),
     stack: z
-      .string()
+      .enum(['ghostscript', 'vips', 'pdfium', 'imagemagick'])
       .optional()
       .describe(`
-The image processing stack to use. Defaults to the robot's preferred stack (ImageMagick).
+Selects the PDF rendering stack. Use \`"ghostscript"\` for the default renderer, \`"pdfium"\` for high-end CAD, blueprint, floorplan, or other complex high-DPI PDFs where Ghostscript is too slow or exhausts scratch space, and \`"vips"\` only when libvips PDF loading is explicitly needed. The \`"imagemagick"\` value is kept for internal/backwards-compatible use and should not be used in new public templates.
 `),
     // Override to support lowercase for BC:
     alpha: z

package/src/alphalib/types/robots/file-filter.ts

@@ -59,6 +59,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
@@ -109,7 +113,7 @@ 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. Examples:
+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"]]\`

package/src/alphalib/types/robots/file-watermark.ts

@@ -3,9 +3,10 @@ import { z } from 'zod'
 import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
-// @ts-expect-error - FileWatermarkRobot is not ready yet @TODO please supply missing keys
 export const meta: RobotMetaInput = {
-  name: 'FileWatermarkRobot',
+  bytescount: 4,
+  discount_factor: 0.25,
+  discount_pct: 75,
   example_code: {
     steps: {
       watermarked: {
@@ -16,6 +17,19 @@ export const meta: RobotMetaInput = {
     },
   },
   example_code_description: 'Apply randomized watermarking to uploaded files:',
+  minimum_charge: 0,
+  output_factor: 1,
+  override_lvl1: 'Image Manipulation',
+  purpose_sentence: 'applies randomized watermarks to uploaded media',
+  purpose_verb: 'write',
+  purpose_word: 'watermark files',
+  purpose_words: 'Watermark files',
+  service_slug: 'image-manipulation',
+  slot_count: 20,
+  title: 'Apply watermarks to files',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'file',
+  name: 'FileWatermarkRobot',
   priceFactor: 4,
   queueSlotCount: 20,
   isAllowedForUrlTransform: true,

package/src/alphalib/types/robots/http-import.ts

@@ -6,6 +6,7 @@ import {
   return_file_stubs,
   robotBase,
   robotImport,
+  robotUseWithHiddenFields,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
@@ -85,6 +86,10 @@ Headers can be specified as:
 - An array of strings in the format "Header-Name: value"
 - An array of objects with header names as keys and values as values
 - A JSON string that will be parsed into an object
+
+The same \`headers\` value is sent with every URL in this \`/http/import\` Step. If \`url\` is an
+array, \`headers\` is not matched to the URLs by array index. Use separate \`/http/import\` Steps
+when different URLs need different headers.
 `),
     import_on_errors: z
       .array(z.string())
@@ -123,8 +128,9 @@ Allows you to specify one or more byte ranges to import from the file. The serve
   })
   .strict()
 
-export const robotHttpImportInstructionsWithHiddenFieldsSchema =
-  robotHttpImportInstructionsSchema.extend({
+export const robotHttpImportInstructionsWithHiddenFieldsSchema = robotHttpImportInstructionsSchema
+  .merge(robotUseWithHiddenFields)
+  .extend({
     force_original_id: z.string().optional(),
     force_name: z
       .union([z.string(), z.record(z.string())])

package/src/alphalib/types/robots/image-optimize.ts

@@ -54,7 +54,7 @@ This <dfn>Robot</dfn> enables you to lower your storage and bandwidth costs, and
 It works well together with [🤖/image/resize](/docs/robots/image-resize/) to bring the full power of resized and optimized images to your website or app.
 
 > [!Note]
-> This <dfn>Robot</dfn> accepts all image types and will just pass on unsupported image types unoptimized. Hence, there is no need to set up [🤖/file/filter](/docs/robots/file-filter/) workflows for this.
+> This <dfn>Robot</dfn> accepts all image types and will just pass on unsupported image types unoptimized, including JPEG XL (\`.jxl\`) images when no smaller optimized result can be produced. Hence, there is no need to set up [🤖/file/filter](/docs/robots/file-filter/) workflows for this.
 
 > [!Note]
 > PNG optimization uses only lossless (optipng) compressors by default. To also enable lossy compression (pngquant), set \`lossy: true\`. When enabled, both lossy and lossless compressors compete and the smallest result wins, which may cause color shifts in some images.

package/src/alphalib/types/robots/image-resize.ts

@@ -162,7 +162,7 @@ export const robotImageResizeInstructionsSchema = robotBase
       .describe(`
 The output format for the modified image.
 
-Some of the most important available formats are \`"jpg"\`, \`"png"\`, \`"gif"\`, and \`"tiff"\`. For a complete lists of all formats that we can write to please check [our supported image formats list](/docs/supported-formats/image-formats/).
+Some of the most important available formats are \`"jpg"\`, \`"png"\`, \`"gif"\`, \`"tiff"\`, and \`"jxl"\` for JPEG XL. For a complete list of all formats that we can write to, please check [our supported image formats list](/docs/supported-formats/image-formats/).
 
 If \`null\` (default), then the input image's format will be used as the output format.
 

package/src/alphalib/types/robots/meta-read.ts

@@ -2,9 +2,11 @@ import { z } from 'zod'
 import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase } from './_instructions-primitives.ts'
 
-// @ts-expect-error - MetaReadRobot is not ready yet @TODO please supply missing keys
 export const meta: RobotMetaInput = {
-  name: 'MetaReadRobot',
+  // api2 tracks /meta/read as a special 1% metadata fee while keeping runtime priceFactor at 0.
+  bytescount: 100,
+  discount_factor: 0.01,
+  discount_pct: 99,
   example_code: {
     steps: {
       metadata: {
@@ -13,6 +15,19 @@ export const meta: RobotMetaInput = {
     },
   },
   example_code_description: 'Read metadata from uploaded files:',
+  minimum_charge: 0,
+  output_factor: 1,
+  override_lvl1: 'Media Cataloging',
+  purpose_sentence: 'reads metadata from uploaded files',
+  purpose_verb: 'read',
+  purpose_word: 'metadata',
+  purpose_words: 'Read file metadata',
+  service_slug: 'media-cataloging',
+  slot_count: 15,
+  title: 'Read file metadata',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'file',
+  name: 'MetaReadRobot',
   priceFactor: 0,
   queueSlotCount: 15,
   isAllowedForUrlTransform: true,

package/src/alphalib/types/robots/progress-simulate.ts

@@ -3,9 +3,10 @@ import { z } from 'zod'
 import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
-// @ts-expect-error - ProgressSimulateRobot is not ready yet @TODO please supply missing keys
 export const meta: RobotMetaInput = {
-  name: 'ProgressSimulateRobot',
+  bytescount: 1,
+  discount_factor: 1,
+  discount_pct: 0,
   example_code: {
     steps: {
       simulate: {
@@ -19,6 +20,19 @@ export const meta: RobotMetaInput = {
     },
   },
   example_code_description: 'Simulate Step progress and output generation for testing:',
+  minimum_charge: 0,
+  output_factor: 1,
+  override_lvl1: 'Code Evaluation',
+  purpose_sentence: 'simulates Step progress and output generation for tests',
+  purpose_verb: 'run',
+  purpose_word: 'progress simulation',
+  purpose_words: 'Simulate Step progress',
+  service_slug: 'code-evaluation',
+  slot_count: 20,
+  title: 'Simulate Step progress',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'file',
+  name: 'ProgressSimulateRobot',
   priceFactor: 1,
   queueSlotCount: 20,
   isAllowedForUrlTransform: false,

package/src/alphalib/types/robots/tlcdn-deliver.ts

@@ -3,9 +3,9 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 20,
-  discount_factor: 0.05,
-  discount_pct: 95,
+  bytescount: 25,
+  discount_factor: 0.04,
+  discount_pct: 96,
   example_code: {
     steps: {
       deliver: {
@@ -27,7 +27,8 @@ export const meta: RobotMetaInput = {
   typical_file_size_mb: 1.2,
   typical_file_type: 'file',
   name: 'TlcdnDeliverRobot',
-  priceFactor: 20,
+  // Baseline factor for non-HIPAA delivery; HIPAA delivery uses a 20% lower factor.
+  priceFactor: 25,
   queueSlotCount: 0,
   minimumCharge: 102400,
   downloadInputFiles: false,
@@ -42,8 +43,15 @@ export const meta: RobotMetaInput = {
 export const robotTlcdnDeliverInstructionsSchema = robotBase
   .extend({
     robot: z.literal('/tlcdn/deliver').describe(`
-When you want Transloadit to tranform files on the fly, this <dfn>Robot</dfn> can cache and deliver the results close to your end-user, saving on latency and encoding volume. The use of this <dfn>Robot</dfn> is implicit when you use the <code>tlcdn.com</code> domain.
+When you want Transloadit to transform files on the fly, this <dfn>Robot</dfn> can cache and deliver the results close to your end-user, saving on latency and encoding volume. The use of this <dfn>Robot</dfn> is implicit when you use the <code>tlcdn.com</code> domain.
 `),
+    enable_hipaa_compliance: z
+      .boolean()
+      .optional()
+      .default(false)
+      .describe(
+        'When enabled, use the HIPAA-compliant Smart CDN pricing profile for this delivery step (20% lower price factor). When disabled, the non-HIPAA baseline price factor applies.',
+      ),
   })
   .strict()
 

package/src/alphalib/types/template.ts

@@ -137,12 +137,12 @@ The \`referer\` property is a regular expression to match against the HTTP refer
 Uploads without a referer will always pass (as they are turned off for some browsers) making this useful in just a handful of use cases. For details about regular expressions, see [Mozilla's RegExp documentation](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/RegExp).
 
 The \`max_size\` property can be used to set a maximum size that an upload can have in bytes, such as \`1048576\` (1 MB). Specify this to prevent users from uploading excessively large files.
-
-This can be set as part of the Assembly request or as part of the Template.
-
 The file size is checked as soon as the upload is started and if it exceeds the maximum size, the entire upload process is canceled and the Assembly will error out, even if it contains files that do not exceed the \`max_size\` limitation.
-
 If you want to just ignore the files that exceed a certain size, but process all others, then please use [🤖/file/filter](https://transloadit.com/docs/robots/file-filter/).
+
+The \`max_number_of_files\` property can be used to set a maximum number of files that an upload can have, such as \`100\`. Specify this to prevent users from uploading excessively many files, both via file uploads and via import Robots.
+
+These properties can be set as part of the Assembly request or as part of the Template.
 `)
 
 const assemblyInstructionsSharedShape = {