@transloadit/node 4.7.6 → 4.7.7

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

@@ -4,7 +4,6 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 1,
   discount_factor: 0.8,
   discount_pct: 20,
@@ -46,9 +45,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
@@ -74,7 +73,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']))])
@@ -88,6 +101,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/src/alphalib/types/robots/file-filter.ts

@@ -9,7 +9,6 @@ import {
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 0,
   discount_factor: 0,
   discount_pct: 100,
@@ -18,7 +17,7 @@ export const meta: RobotMetaInput = {
       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',
       },
@@ -74,9 +73,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]
@@ -98,9 +109,12 @@ As indicated, we charge for this via [🤖/script/run](/docs/robots/script-run/)
     accepts: filterCondition
       .describe(
         `
-Files that match at least one requirement will be accepted, or declined otherwise. If the value is \`null\`, all files will be accepted. If the array is empty, no files will be accepted. Example:
+Files that match at least one requirement will be accepted, or declined otherwise. If the value is \`null\`, all files will be accepted. If the array is empty, no files will be accepted. Examples:
 
-\`[["\${file.mime}", "==", "image/gif"]]\`.
+\`[["\${file.mime}", "==", "image/gif"]]\`
+\`[["\${file.size}", "<", "5kb"]]\`
+
+For numeric comparisons (\`<\`, \`>\`, \`<=\`, \`>=\`), human-readable byte values such as \`"20mb"\`, \`"1gb"\`, or \`"512kb"\` are supported.
 
 If the \`condition_type\` parameter is set to \`"and"\`, then all requirements must match for the file to be accepted.
 
@@ -111,9 +125,12 @@ If \`accepts\` and \`declines\` are both provided, the requirements in \`accepts
     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/src/alphalib/types/robots/file-hash.ts

@@ -4,7 +4,6 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: false,
   bytescount: 5,
   discount_factor: 0.2,
   discount_pct: 80,
@@ -52,6 +51,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()

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

@@ -13,7 +13,6 @@ import {
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 1,
   discount_factor: 1,
   discount_pct: 0,
@@ -83,6 +82,14 @@ See the list of available [resize strategies](/docs/topics/resize-strategies/) f
 `),
     background: color_with_alpha.default('#ffffffff').describe(`
 The hexadecimal code of the color used to fill the background (only used for the pad resize strategy). The format is \`#rrggbb[aa]\` (red, green, blue, alpha). Use \`#00000000\` for a transparent padding.
+`),
+    zoom: z
+      .boolean()
+      .default(true)
+      .describe(`
+If set to \`false\`, smaller images will not be stretched to the desired \`width\` and \`height\`. This is useful if you want to retain the original image dimensions and only limit the output to a maximum size. For details about the impact of zooming for your preferred resize strategy, see the list of available [resize strategies](/docs/topics/resize-strategies/).
+
+Note that this parameter only affects strategies that produce a still image. Animated clips generated by the \`clip\` strategy are not affected.
 `),
     strategy: z
       .object({

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

@@ -4,10 +4,18 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 5,
   discount_factor: 0.2,
   discount_pct: 80,
+  example_code: {
+    steps: {
+      read: {
+        robot: '/file/read',
+        use: ':original',
+      },
+    },
+  },
+  example_code_description: 'Read UTF-8 text content from an uploaded file:',
   minimum_charge: 512000,
   output_factor: 1,
   override_lvl1: 'Document Processing',

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

@@ -4,10 +4,26 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 4,
   discount_factor: 0.25,
   discount_pct: 75,
+  example_code: {
+    steps: {
+      resized: {
+        robot: '/image/resize',
+        use: ':original',
+        width: 800,
+        height: 450,
+        resize_strategy: 'fit',
+      },
+      served: {
+        robot: '/file/serve',
+        use: 'resized',
+        cache_duration: 86400,
+      },
+    },
+  },
+  example_code_description: 'Serve transformed files with explicit browser and CDN cache duration:',
   minimum_charge: 0,
   output_factor: 1,
   purpose_sentence: 'serves files to web browsers',
@@ -35,7 +51,7 @@ export const robotFileServeInstructionsSchema = robotBase
   .merge(robotUse)
   .extend({
     robot: z.literal('/file/serve').describe(`
-When you want Transloadit to tranform files on the fly, you can use this <dfn>Robot</dfn> to determine which <dfn>Step</dfn> of a <dfn>Template</dfn> should be served to the end-user (via a CDN), as well as set extra information on the served files, such as headers. This way you can for instance suggest the CDN for how long to keep cached copies of the result around. By default, as you can see in the \`headers\` parameter, we instruct browsers to cache the result for 72h (\`259200\` seconds) and CDNs to cache the content for 24h (\`86400\` seconds). These values should be adjusted to suit your use case.
+When you want Transloadit to tranform files on the fly, you can use this <dfn>Robot</dfn> to determine which <dfn>Step</dfn> of a <dfn>Template</dfn> should be served to the end-user (via a CDN), as well as set extra information on the served files, such as headers. This way you can for instance suggest the CDN for how long to keep cached copies of the result around. By default, we instruct browsers to cache the result for 72h (\`259200\` seconds) and CDNs to cache the content for 24h (\`86400\` seconds). Use the \`cache_duration\` parameter to customize both values at once.
 
 🤖/file/serve merely acts as the glue layer between our <dfn>Assembly</dfn> engine and serving files over HTTP. It let's you pick the proper result of a series of <dfn>Steps</dfn> via the \`use\` parameter and configure headers on the original content. That is where its responsibilies end, and 🤖/tlcdn/deliver, then takes over to globally distribute this original content across the globe, and make sure that is cached close to your end-users, when they make requests such as <https://my-app.tlcdn.com/resize-img/canoe.jpg?w=500>, another. 🤖/tlcdn/deliver is not a part of your <dfn>Assembly Instructions</dfn>, but it may appear on your invoices as bandwidth charges incur when distributing the cached copies. 🤖/file/serve only charges when the CDN does not have a cached copy and requests to regenerate the original content, which depending on your caching settings could be just once a month, or year, per file/transformation.
 
@@ -43,9 +59,9 @@ While theoretically possible, you could use [🤖/file/serve](/docs/robots/file-
 
 Also consider configuring caching headers and cache-control directives to control how content is cached and invalidated on the CDN edge servers, balancing between freshness and efficiency.
 
-## Smart CDN Security with Signature Authentication
+## Smart CDN security with signed URLs
 
-You can leverage [Signature Authentication](/docs/api/authentication/#smart-cdn) to avoid abuse of our encoding platform. Below is a quick Node.js example using our Node SDK, but there are [examples for other languages and SDKs](/docs/api/authentication/#example-code) as well.
+You can leverage [signed Smart CDN URLs](/docs/api/authentication/#smart-cdn) to avoid abuse of our encoding platform. Below is a quick Node.js example using our Node SDK, but there are [examples for other languages and SDKs](/docs/api/authentication/#example-code) as well.
 
 \`\`\`javascript
 // yarn add transloadit
@@ -71,28 +87,44 @@ console.log(url)
 
 This will generate a signed Smart CDN URL that includes authentication parameters, preventing unauthorized access to your transformation endpoints.
 
+For new integrations, use the modern \`sig\` + \`exp\` format. Legacy \`s\` signatures are deprecated. Also note that the expiration window is the practical cache window for signed results: shorter expirations tighten access control, while longer expirations improve cache reuse and lower encoding volume.
+
 ## More information
 
 - [Content Delivery](/services/content-delivery/)
 - [🤖/file/serve](/docs/robots/file-serve/) pricing
 - [🤖/tlcdn/deliver](/docs/robots/tlcdn-deliver/) pricing
 - [File Preview Feature](/blog/2024/06/file-preview-with-smart-cdn/) blog post
+`),
+    cache_duration: z
+      .number()
+      .int()
+      .min(0)
+      .optional()
+      .describe(`
+An optional duration in seconds that the served file should be cached. When set, this value is used for both the \`max-age\` (browser cache) and \`s-maxage\` (shared/CDN cache) directives in the \`Cache-Control\` header, overriding the defaults. For example, setting \`cache_duration\` to \`43200\` would cache the file for 12 hours.
+
+This is useful for controlling data retention in CDNs. For instance, if your temporary files are deleted after 24 hours, you can set \`cache_duration\` to \`86400\` to ensure cached copies also expire within that window.
 `),
     headers: z
       .record(z.string())
       .default({
         'Access-Control-Allow-Headers':
-          'X-Requested-With, Content-Type, Cache-Control, Accept, Content-Length, Transloadit-Client, Authorization',
+          'X-Requested-With, Content-Type, Cache-Control, Accept, Content-Length, Transloadit-Client, Authorization, Range, If-Range',
         'Access-Control-Allow-Methods': 'POST, GET, PUT, DELETE, OPTIONS',
         'Access-Control-Allow-Origin': '*',
-        'Cache-Control': 'public, max-age=259200, s-max-age=86400',
+        'Access-Control-Expose-Headers':
+          'Transloadit-Assembly-URL, Content-Range, Content-Length, Accept-Ranges',
+        'Cache-Control': 'public, max-age=259200, s-maxage=86400',
         'Content-Type': '${file.mime}; charset=utf-8',
-        'Transfer-Encoding': 'chunked',
         'Transloadit-Assembly': '…',
         'Transloadit-RequestID': '…',
+        'Accept-Ranges': 'bytes',
       })
       .describe(`
 An object containing a list of headers to be set for a file as we serve it to a CDN/web browser, such as \`{ FileURL: "\${file.url_name}" }\` which will be merged over the defaults, and can include any available [Assembly Variable](/docs/topics/assembly-instructions/#assembly-variables).
+
+The \`Accept-Ranges: bytes\` header advertises that HTTP range requests are supported for seekable media playback. This relies on Transloadit's storage backends (S3, GCS, etc.) all honoring Range request headers. The CORS headers include \`Range\` and \`If-Range\` in \`Access-Control-Allow-Headers\` to permit cross-origin range requests, and expose \`Content-Range\`, \`Content-Length\`, and \`Accept-Ranges\` via \`Access-Control-Expose-Headers\` so browser JavaScript can read these values.
 `),
   })
   .strict()

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

@@ -4,7 +4,6 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 4,
   description:
     '/file/verify is a simple Robot that helps ensure that the files you upload are of the type you initially intended. This is especially useful when handling user-generated content, where you may not want to run certain Steps in your Template if the user hasn’t uploaded a file of the correct type. Another use case for /file/verify is when a user uploads a ZIP file, but we find that it has a few damaged files inside when we extract it. Perhaps you don’t want to error out, but only send the good files to a next processing step. With /file/verify, you can do exactly that (assuming the default of `error_on_decline`: `true`).',

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

@@ -4,7 +4,6 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: false,
   bytescount: 1,
   description:
     'While 100% security is a myth, having /file/virusscan as a gatekeeper bot helps reject millions of trojans, viruses, malware & other malicious threats before they reach your platform.',
@@ -32,16 +31,19 @@ export const meta: RobotMetaInput = {
   purpose_word: 'scan for viruses and reject malware',
   purpose_words: 'Scan files for viruses',
   service_slug: 'file-filtering',
-  slot_count: 38,
+  slot_count: 16,
   title: 'Scan files for viruses',
   typical_file_size_mb: 1.2,
   typical_file_type: 'file',
   name: 'FileVirusscanRobot',
   priceFactor: 1,
-  queueSlotCount: 38,
+  queueSlotCount: 16,
   minimumCharge: 1048576,
   lazyLoad: true,
-  installVersionFile: process.env.API2_CLAMD_INSTALL_VERSION_FILE || '',
+  installVersionFile:
+    typeof process !== 'undefined' && process.env.API2_CLAMD_INSTALL_VERSION_FILE
+      ? process.env.API2_CLAMD_INSTALL_VERSION_FILE
+      : '',
   isAllowedForUrlTransform: false,
   trackOutputFileSize: true,
   isInternal: false,

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

@@ -6,6 +6,16 @@ import { interpolateRobot, robotBase, robotUse } from './_instructions-primitive
 // @ts-expect-error - FileWatermarkRobot is not ready yet @TODO please supply missing keys
 export const meta: RobotMetaInput = {
   name: 'FileWatermarkRobot',
+  example_code: {
+    steps: {
+      watermarked: {
+        robot: '/file/watermark',
+        use: ':original',
+        randomize: true,
+      },
+    },
+  },
+  example_code_description: 'Apply randomized watermarking to uploaded files:',
   priceFactor: 4,
   queueSlotCount: 20,
   isAllowedForUrlTransform: true,

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

@@ -10,7 +10,6 @@ import {
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 10,
   discount_factor: 0.1,
   discount_pct: 90,

package/src/alphalib/types/robots/ftp-store.ts

@@ -4,7 +4,6 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { ftpBase, interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 6,
   discount_factor: 0.15000150001500018,
   discount_pct: 84.99984999849998,

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

@@ -13,7 +13,6 @@ import {
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 10,
   discount_factor: 0.1,
   discount_pct: 90,

package/src/alphalib/types/robots/google-store.ts

@@ -4,7 +4,6 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { googleBase, interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 6,
   discount_factor: 0.15000150001500018,
   discount_pct: 84.99984999849998,

package/src/alphalib/types/robots/html-convert.ts

@@ -4,7 +4,6 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 1,
   discount_factor: 1,
   discount_pct: 0,

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

@@ -9,7 +9,6 @@ import {
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 10,
   discount_factor: 0.1,
   discount_pct: 90,

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

@@ -4,7 +4,6 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   discount_factor: 1,
   bytescount: 1,
   discount_pct: 0,
@@ -48,7 +47,10 @@ export const robotImageBgremoveInstructionsSchema = robotBase
       .enum(['foreground', 'background'])
       .optional()
       .describe('Region to select and keep in the image. The other region is removed.'),
-    format: z.enum(['png', 'gif', 'webp']).optional().describe('Format of the generated image.'),
+    format: z
+      .enum(['png', 'gif', 'webp'])
+      .default('png')
+      .describe('Format of the generated image. Defaults to PNG when not provided.'),
     provider: z
       .enum(['transloadit', 'replicate', 'fal'])
       .optional()

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

@@ -0,0 +1,167 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  bytescount: 1,
+  discount_factor: 1,
+  discount_pct: 0,
+  example_code: {
+    steps: {
+      copyright_checked: {
+        robot: '/image/copyrightdetect',
+        use: ':original',
+        confidence_threshold: 80,
+        error_on_decline: true,
+        error_msg: 'This image appears to be a known stock photo. Please upload original content.',
+      },
+    },
+  },
+  example_code_description:
+    'Detect known stock photos and copyrighted works in uploaded images and reject flagged files:',
+  extended_description: `
+> [!Note]
+> This <dfn>Robot</dfn> detects **known stock photos, brand logos, and watermarked images** by performing reverse image lookups against web databases. It is best understood as "stock photo detection" — it tells you if an uploaded image matches a known copyrighted work in indexed databases (Getty Images, Shutterstock, Adobe Stock, etc.), not whether an image is copyrighted in the legal sense (since technically all photos are copyrighted by their creator).
+
+> [!Warning]
+> This <dfn>Robot</dfn> provides a **risk signal**, not a legal determination. Results should be interpreted as "potentially copyrighted" — never as definitive proof of infringement. Copyright law varies by jurisdiction and the system cannot know if a user holds a valid license. We recommend using this Robot as one input in a broader content moderation workflow.
+
+> [!Warning]
+> Transloadit aims to be deterministic, but this <dfn>Robot</dfn> uses third-party AI services. The providers will evolve their models over time, giving different responses for the same input images. Avoid relying on exact responses in your tests and application.
+
+> [!Tip]
+> If you want to keep only files below your confidence threshold (for example keep 20 out of 100), set \`format\` to \`"meta"\` and add a [🤖/file/filter](/docs/robots/file-filter/) Step after this one:
+>
+> ~~~json
+> {
+>   "steps": {
+>     "copyright_scan": {
+>       "robot": "/image/copyrightdetect",
+>       "use": ":original",
+>       "format": "meta",
+>       "confidence_threshold": 80,
+>       "error_on_decline": false
+>     },
+>     "keep_safe": {
+>       "robot": "/file/filter",
+>       "use": "copyright_scan",
+>       "declines": "\${file.meta.copyright?.flagged === true}"
+>     }
+>   }
+> }
+> ~~~
+>
+> In this setup, files with at least one match at or above your threshold are declined, and only the remaining files continue to later Steps.
+`,
+  minimum_charge: 1572864,
+  output_factor: 0.05,
+  override_lvl1: 'Artificial Intelligence',
+  purpose_sentence:
+    'detects known stock photos, brand logos, and watermarked images in uploaded files using reverse image search',
+  purpose_verb: 'detect',
+  purpose_word: 'detect stock photos and copyrighted works',
+  purpose_words: 'Detect known stock photos and copyrighted works in images',
+  service_slug: 'artificial-intelligence',
+  slot_count: 10,
+  title: 'Detect known stock photos and copyrighted works in images',
+  typical_file_size_mb: 0.8,
+  typical_file_type: 'image',
+  name: 'ImageCopyrightdetectRobot',
+  priceFactor: 1,
+  queueSlotCount: 10,
+  minimumChargeUsd: 0.0013,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'alpha',
+}
+
+export const robotImageCopyrightdetectInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/image/copyrightdetect').describe(`
+Detects known stock photos, brand logos, and watermarked images in uploaded files by performing reverse image lookups against web databases. This is best understood as "stock photo detection" — it identifies whether an uploaded image matches a known copyrighted work in indexed databases (Getty Images, Shutterstock, Adobe Stock, etc.).
+
+Returns a \`licenses[]\` array with match details including source collection, license type, confidence scores, and source URLs. Can optionally halt the <dfn>Assembly</dfn> when a known copyrighted work is detected, similar to how \`/file/virusscan\` handles malicious files.
+
+This <dfn>Robot</dfn> provides a **risk signal**, not a legal determination. A match means the image was found in a stock photo or rights-managed database — it does not mean the user lacks a valid license.
+`),
+    confidence_threshold: z
+      .number()
+      .min(0)
+      .max(100)
+      .default(80)
+      .describe(`
+Minimum confidence percentage (0\u2013100) for a match to be considered a copyright concern. Matches below this threshold are still returned in results but not flagged. Higher values reduce false positives but may miss some matches.
+`),
+    categories: z
+      .array(z.enum(['stock_photo', 'brand_logo', 'artwork', 'watermarked', 'all']))
+      .nonempty()
+      .default(['all'])
+      .describe(`
+Which categories of copyrighted content to detect.
+
+- \`"stock_photo"\` \u2014 Known stock photography (Shutterstock, Getty, Adobe Stock, etc.)
+- \`"brand_logo"\` \u2014 Registered brand logos and trademarks
+- \`"artwork"\` \u2014 Famous artworks and illustrations
+- \`"watermarked"\` \u2014 Images containing visible watermarks
+- \`"all"\` \u2014 All categories
+`),
+    error_on_decline: z
+      .boolean()
+      .default(false)
+      .describe(`
+If set to \`true\` and one or more files match a known stock photo or copyrighted work (above the \`confidence_threshold\`), the <dfn>Assembly</dfn> will be stopped and marked with an error. Works the same way as \`/file/virusscan\`'s \`error_on_decline\`.
+`),
+    error_msg: z
+      .string()
+      .default('One of your files matched a known stock photo or copyrighted work')
+      .describe(`
+The error message shown to your users (such as by Uppy) when a file is declined and \`error_on_decline\` is set to \`true\`.
+`),
+    format: z
+      .enum(['json', 'meta'])
+      .default('json')
+      .describe(`
+In what format to return the detection results.
+
+- \`"json"\` returns a JSON file with full match details including \`licenses[]\`, plus summary fields \`flagged\`, \`max_confidence\`, and \`confidence_threshold\`.
+- \`"meta"\` does not return a file, but stores the same data object (including \`licenses[]\`, \`flagged\`, \`max_confidence\`, and \`confidence_threshold\`) inside Transloadit's file object (under \`\${file.meta.copyright}\`) that's passed around between encoding <dfn>Steps</dfn>, so that you can use the values to filter on them, etc.
+`),
+  })
+  .strict()
+
+export const robotImageCopyrightdetectInstructionsWithHiddenFieldsSchema =
+  robotImageCopyrightdetectInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotImageCopyrightdetectInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotImageCopyrightdetectInstructions = z.infer<
+  typeof robotImageCopyrightdetectInstructionsSchema
+>
+export type RobotImageCopyrightdetectInstructionsWithHiddenFields = z.infer<
+  typeof robotImageCopyrightdetectInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotImageCopyrightdetectInstructionsSchema = interpolateRobot(
+  robotImageCopyrightdetectInstructionsSchema,
+)
+export type InterpolatableRobotImageCopyrightdetectInstructions =
+  InterpolatableRobotImageCopyrightdetectInstructionsInput
+
+export type InterpolatableRobotImageCopyrightdetectInstructionsInput = z.input<
+  typeof interpolatableRobotImageCopyrightdetectInstructionsSchema
+>
+
+export const interpolatableRobotImageCopyrightdetectInstructionsWithHiddenFieldsSchema =
+  interpolateRobot(robotImageCopyrightdetectInstructionsWithHiddenFieldsSchema)
+export type InterpolatableRobotImageCopyrightdetectInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotImageCopyrightdetectInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotImageCopyrightdetectInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotImageCopyrightdetectInstructionsWithHiddenFieldsSchema
+>

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

@@ -10,7 +10,6 @@ import {
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 1,
   discount_factor: 1,
   discount_pct: 0,