@transloadit/zod 4.5.0 → 5.0.1

package/dist/v4/robots/youtube-store.d.ts

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotYoutubeStoreInstructionsSchema: 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";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -38,7 +39,6 @@ export declare const robotYoutubeStoreInstructionsSchema: z.ZodObject<{
     title: z.ZodString;
     description: z.ZodString;
     category: z.ZodPreprocess<z.ZodEnum<{
-        "science & technology": "science & technology";
         "autos & vehicles": "autos & vehicles";
         comedy: "comedy";
         education: "education";
@@ -50,25 +50,28 @@ export declare const robotYoutubeStoreInstructionsSchema: z.ZodObject<{
         "news & politics": "news & politics";
         "people & blogs": "people & blogs";
         "pets & animals": "pets & animals";
+        "science & technology": "science & technology";
         sports: "sports";
         "travel & events": "travel & events";
     }>>;
     keywords: z.ZodString;
     visibility: z.ZodEnum<{
-        public: "public";
         private: "private";
+        public: "public";
         unlisted: "unlisted";
     }>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotYoutubeStoreInstructionsSchema.shape>;
 export declare const robotYoutubeStoreInstructionsWithHiddenFieldsSchema: 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";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -96,7 +99,6 @@ export declare const robotYoutubeStoreInstructionsWithHiddenFieldsSchema: z.ZodO
     title: z.ZodString;
     description: z.ZodString;
     category: z.ZodPreprocess<z.ZodEnum<{
-        "science & technology": "science & technology";
         "autos & vehicles": "autos & vehicles";
         comedy: "comedy";
         education: "education";
@@ -108,34 +110,33 @@ export declare const robotYoutubeStoreInstructionsWithHiddenFieldsSchema: z.ZodO
         "news & politics": "news & politics";
         "people & blogs": "people & blogs";
         "pets & animals": "pets & animals";
+        "science & technology": "science & technology";
         sports: "sports";
         "travel & events": "travel & events";
     }>>;
     keywords: z.ZodString;
     visibility: z.ZodEnum<{
-        public: "public";
         private: "private";
+        public: "public";
         unlisted: "unlisted";
     }>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotYoutubeStoreInstructions = z.infer<typeof robotYoutubeStoreInstructionsSchema>;
-export type RobotYoutubeStoreInstructionsWithHiddenFields = z.infer<typeof robotYoutubeStoreInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotYoutubeStoreInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotYoutubeStoreInstructionsSchema: 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";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     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]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -158,7 +159,6 @@ export declare const interpolatableRobotYoutubeStoreInstructionsSchema: z.ZodObj
     title: z.ZodString;
     description: z.ZodString;
     category: z.ZodPreprocess<z.ZodEnum<{
-        "science & technology": "science & technology";
         "autos & vehicles": "autos & vehicles";
         comedy: "comedy";
         education: "education";
@@ -170,32 +170,31 @@ export declare const interpolatableRobotYoutubeStoreInstructionsSchema: z.ZodObj
         "news & politics": "news & politics";
         "people & blogs": "people & blogs";
         "pets & animals": "pets & animals";
+        "science & technology": "science & technology";
         sports: "sports";
         "travel & events": "travel & events";
     }>>;
     keywords: z.ZodString;
     visibility: z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        public: "public";
         private: "private";
+        public: "public";
         unlisted: "unlisted";
     }>]>;
-}, z.core.$strict>;
-export type InterpolatableRobotYoutubeStoreInstructions = InterpolatableRobotYoutubeStoreInstructionsInput;
-export type InterpolatableRobotYoutubeStoreInstructionsInput = z.input<typeof interpolatableRobotYoutubeStoreInstructionsSchema>;
-export declare const interpolatableRobotYoutubeStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotYoutubeStoreInstructionsWithHiddenFieldsSchema: 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";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     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>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -218,7 +217,6 @@ export declare const interpolatableRobotYoutubeStoreInstructionsWithHiddenFields
     title: z.ZodString;
     description: z.ZodString;
     category: z.ZodPreprocess<z.ZodEnum<{
-        "science & technology": "science & technology";
         "autos & vehicles": "autos & vehicles";
         comedy: "comedy";
         education: "education";
@@ -230,17 +228,24 @@ export declare const interpolatableRobotYoutubeStoreInstructionsWithHiddenFields
         "news & politics": "news & politics";
         "people & blogs": "people & blogs";
         "pets & animals": "pets & animals";
+        "science & technology": "science & technology";
         sports: "sports";
         "travel & events": "travel & events";
     }>>;
     keywords: z.ZodString;
     visibility: z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        public: "public";
         private: "private";
+        public: "public";
         unlisted: "unlisted";
     }>]>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
-export type InterpolatableRobotYoutubeStoreInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotYoutubeStoreInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotYoutubeStoreInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotYoutubeStoreInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotYoutubeStoreInstructions = Instructions['output'];
+export type RobotYoutubeStoreInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotYoutubeStoreInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotYoutubeStoreInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotYoutubeStoreInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotYoutubeStoreInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=youtube-store.d.ts.map

package/dist/v4/robots/youtube-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"youtube-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/youtube-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAwClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAwErC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}
+{"version":3,"file":"youtube-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/youtube-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAgD1B,eAAO,MAAM,IAAI,EAAE,cAiBlB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiDrC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,mCAAmC,CAAC,KAAK,CACtC,CAAA;AAExD,eAAO,MACa,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACrD,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACjC,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAChF,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,6BAA6B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAClE,MAAM,MAAM,6CAA6C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACxF,MAAM,MAAM,2CAA2C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC7F,MAAM,MAAM,gDAAgD,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAClG,MAAM,MAAM,2DAA2D,GACrE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,gEAAgE,GAC1E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

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

@@ -1,45 +1,49 @@
 import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { zodCodePointLength, zodWithJsonInputSchema } from "../lib/zodInputSemantics.js";
+import { createProcessingExample, defineRobot, robotBase, robotStoreMeta, robotUse, } from "./_instructions-primitives.js";
+const youtubeCategories = [
+    'autos & vehicles',
+    'comedy',
+    'education',
+    'entertainment',
+    'film & animation',
+    'gaming',
+    'howto & style',
+    'music',
+    'news & politics',
+    'people & blogs',
+    'pets & animals',
+    'science & technology',
+    'sports',
+    'travel & events',
+];
+function asciiCaseInsensitiveLiteral(value) {
+    return [...value]
+        .map((character) => character >= 'a' && character <= 'z' ? `[${character}${character.toUpperCase()}]` : character)
+        .join('');
+}
+const youtubeCategoryValueSchema = z.enum(youtubeCategories);
+const youtubeCategoryInputSchema = z
+    .string()
+    .regex(new RegExp(`^(?:${youtubeCategories.map(asciiCaseInsensitiveLiteral).join('|')})$`, 'u'));
+const youtubeCategorySchema = zodWithJsonInputSchema(z.preprocess((value) => (typeof value === 'string' ? value.toLowerCase() : value), youtubeCategoryValueSchema), youtubeCategoryInputSchema);
 export const meta = {
-    bytescount: 6,
-    discount_factor: 0.15000150001500018,
-    discount_pct: 84.99984999849998,
+    ...robotStoreMeta,
     hideCredentialsWarning: true,
-    example_code: {
-        steps: {
-            exported: {
-                robot: '/youtube/store',
-                use: ':original',
-                credentials: 'YOUR_YOUTUBE_CREDENTIALS',
-                title: 'Transloadit: Video Example',
-                description: 'Some nice description',
-                category: 'science & technology',
-                keywords: 'transloadit, robots, botty',
-                visibility: 'private',
-            },
-        },
-    },
+    example_code: createProcessingExample('exported', '/youtube/store', {
+        credentials: 'YOUR_YOUTUBE_CREDENTIALS',
+        title: 'Transloadit: Video Example',
+        description: 'Some nice description',
+        category: 'science & technology',
+        keywords: 'transloadit, robots, botty',
+        visibility: 'private',
+    }),
     example_code_description: 'Export an uploaded video to YouTube and set some basic parameters:',
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Exporting',
     purpose_sentence: 'exports encoding results to YouTube',
-    purpose_verb: 'export',
     purpose_word: 'YouTube',
     purpose_words: 'Export files to YouTube',
-    service_slug: 'file-exporting',
-    slot_count: 10,
     title: 'Export files to YouTube',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'YoutubeStoreRobot',
-    priceFactor: 6.6666,
-    queueSlotCount: 10,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotYoutubeStoreInstructionsSchema = robotBase
     .merge(robotUse)
@@ -67,15 +71,12 @@ You can add a custom thumbnail to your video on YouTube by using our \`"as"\` sy
 },
 \`\`\`
 
-If you encounter an error such as "The authenticated user doesnʼt have permissions to upload and set custom video thumbnails", you should go to your YouTube account and try adding a custom thumbnail to one of your existing videos. Youʼll be prompted to add your phone number. Once youʼve added it, the error should go away.
+If you encounter an error such as "The authenticated user doesn’t have permissions to upload and set custom video thumbnails", you should go to your YouTube account and try adding a custom thumbnail to one of your existing videos. You’ll be prompted to add your phone number. Once you’ve added it, the error should go away.
 `),
     credentials: z.string().describe(`
 The authentication Template credentials used for your YouTube account. You can generate them on the [Template Credentials page](/c/template-credentials/). Simply add the name of your YouTube channel, and you will be redirected to a Google verification page. Accept the presented permissions and you will be good to go.
 `),
-    title: z
-        .string()
-        .max(80)
-        .describe(`
+    title: zodCodePointLength(z.string(), { max: 80 }).describe(`
 The title of the video to be displayed on YouTube.
 
 Note that since the YouTube API requires titles to be within 80 characters, longer titles may be truncated.
@@ -83,24 +84,7 @@ Note that since the YouTube API requires titles to be within 80 characters, long
     description: z.string().describe(`
 The description of the video to be displayed on YouTube. This can be up to 5000 characters, including \`\\n\` for new-lines.
 `),
-    category: z
-        .preprocess((val) => (typeof val === 'string' ? val.toLowerCase() : val), z.enum([
-        'autos & vehicles',
-        'comedy',
-        'education',
-        'entertainment',
-        'film & animation',
-        'gaming',
-        'howto & style',
-        'music',
-        'news & politics',
-        'people & blogs',
-        'pets & animals',
-        'science & technology',
-        'sports',
-        'travel & events',
-    ]))
-        .describe(`
+    category: youtubeCategorySchema.describe(`
 The category to which this video will be assigned.
 `),
     keywords: z.string().describe(`
@@ -111,10 +95,5 @@ Defines the visibility of the uploaded video.
 `),
 })
     .strict();
-export const robotYoutubeStoreInstructionsWithHiddenFieldsSchema = robotYoutubeStoreInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotYoutubeStoreInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotYoutubeStoreInstructionsSchema = interpolateRobot(robotYoutubeStoreInstructionsSchema);
-export const interpolatableRobotYoutubeStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(robotYoutubeStoreInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotYoutubeStoreInstructionsSchema);
+export const { withHiddenFields: robotYoutubeStoreInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotYoutubeStoreInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotYoutubeStoreInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v4/skillFrontmatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skillFrontmatter.d.ts","sourceRoot":"","sources":["../../src/v4/skillFrontmatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;iBAejC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}
+{"version":3,"file":"skillFrontmatter.d.ts","sourceRoot":"","sources":["../../src/v4/skillFrontmatter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;iBAejC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/v4/skillFrontmatter.js

@@ -1,3 +1,4 @@
+import { optionalWithV3Semantics } from "./lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
 /**
  * Zod schema for Agent Skills SKILL.md frontmatter.
@@ -11,8 +12,8 @@ export const skillFrontmatterSchema = z.object({
         .regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, 'Lowercase alphanumeric and hyphens only; must not start/end with hyphen')
         .refine((v) => !v.includes('--'), 'Must not contain consecutive hyphens'),
     description: z.string().min(1).max(1024),
-    license: z.string().optional(),
-    compatibility: z.string().max(500).optional(),
-    metadata: z.record(z.string(), z.string()).optional(),
-    'allowed-tools': z.string().optional(),
+    license: optionalWithV3Semantics(z.string()),
+    compatibility: optionalWithV3Semantics(z.string().max(500)),
+    metadata: optionalWithV3Semantics(z.record(z.string(), z.string())),
+    'allowed-tools': optionalWithV3Semantics(z.string()),
 });

package/dist/v4/stackVersions.d.ts

@@ -1,6 +1,45 @@
+/** Runtime stack selection, ordered oldest to newest; stack IDs are not tool version numbers. */
+export declare const runtimeStackVersions: {
+    readonly exiftool: {
+        readonly default: "v13.36";
+        readonly valid: readonly ["v13.36"];
+    };
+    readonly mplayer: {
+        readonly default: "v1.5.0";
+        readonly valid: readonly ["v1.5.0"];
+    };
+    readonly mediainfo: {
+        readonly default: "v23.10";
+        readonly valid: readonly ["v23.10"];
+    };
+    readonly imagemagick: {
+        readonly default: "v2.0.10";
+        readonly deprecated: {
+            readonly 'v2.0.9': "v2.0.10";
+            readonly 'v3.0.0': "v3.0.1";
+        };
+        readonly valid: readonly ["v2.0.10", "v3.0.1"];
+    };
+    readonly ffmpeg: {
+        readonly default: "v6.0.0";
+        readonly deprecated: {
+            readonly 'v5.0.0': "v6.0.0";
+        };
+        readonly autoUpgradeAfter: {
+            readonly 'v5.0.0': "2026-04-30T00:00:00.000Z";
+        };
+        readonly valid: readonly ["v6.0.0", "v7.0.0", "v8.0.0"];
+        readonly highest: "v8.0.0";
+    };
+    readonly file: {
+        readonly default: "v5.46";
+        readonly valid: readonly ["v5.46"];
+    };
+};
+/** Public authoring recommendations, deliberately distinct from applied runtime defaults. */
 export declare const stackVersions: {
     ffmpeg: {
-        recommendedVersion: "v6";
+        recommendedVersion: "v7";
         test: RegExp;
         suggestedValues: readonly ["v6", "v7", "v8"];
     };

package/dist/v4/stackVersions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stackVersions.d.ts","sourceRoot":"","sources":["../../src/v4/stackVersions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;;;;;;;;;;;CAWzB,CAAA"}
+{"version":3,"file":"stackVersions.d.ts","sourceRoot":"","sources":["../../src/v4/stackVersions.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBvB,CAAA;AAEV,6FAA6F;AAC7F,eAAO,MAAM,aAAa;;;;;;;;;;;CAWzB,CAAA"}

package/dist/v4/stackVersions.js

@@ -1,12 +1,34 @@
+/** Runtime stack selection, ordered oldest to newest; stack IDs are not tool version numbers. */
+export const runtimeStackVersions = {
+    exiftool: { default: 'v13.36', valid: ['v13.36'] },
+    mplayer: { default: 'v1.5.0', valid: ['v1.5.0'] },
+    mediainfo: { default: 'v23.10', valid: ['v23.10'] },
+    imagemagick: {
+        default: 'v2.0.10',
+        // Normalizers upgrade these versions; AssemblyValidator supplies deprecation warnings.
+        deprecated: { 'v2.0.9': 'v2.0.10', 'v3.0.0': 'v3.0.1' },
+        valid: ['v2.0.10', 'v3.0.1'],
+    },
+    ffmpeg: {
+        default: 'v6.0.0',
+        // v5 remains accepted input but its binary has been retired after this cutoff.
+        deprecated: { 'v5.0.0': 'v6.0.0' },
+        autoUpgradeAfter: { 'v5.0.0': '2026-04-30T00:00:00.000Z' },
+        valid: ['v6.0.0', 'v7.0.0', 'v8.0.0'],
+        highest: 'v8.0.0',
+    },
+    file: { default: 'v5.46', valid: ['v5.46'] },
+};
+/** Public authoring recommendations, deliberately distinct from applied runtime defaults. */
 export const stackVersions = {
     ffmpeg: {
-        recommendedVersion: 'v6',
-        test: /^v?[5-8](\.\d+)?(\.\d+)?$/,
+        recommendedVersion: 'v7',
+        test: /^v?[5-8](\.[0-9]+)?(\.[0-9]+)?$/u,
         suggestedValues: ['v6', 'v7', 'v8'],
     },
     imagemagick: {
         recommendedVersion: 'v3',
-        test: /^v?[23](\.\d+)?(\.\d+)?$/,
+        test: /^v?[23](\.[0-9]+)?(\.[0-9]+)?$/u,
         suggestedValues: ['v2', 'v3'],
     },
 };

package/dist/v4/storageAsset.d.ts

@@ -22,6 +22,12 @@ export declare const storedAssetSchema: z.ZodObject<{
 }, z.core.$strip>;
 /** Store, read and recovery share this version-pinned shape, including optional placeholders. */
 export type StoredAsset = z.infer<typeof storedAssetSchema>;
+/** Shared explanations for portable client options and normalized API request fields. */
+export declare const damAssetsListDescriptions: {
+    readonly prefix: "Only list current asset paths starting with this case-sensitive prefix. The empty default includes the whole Workspace; include a trailing slash to select a directory boundary.";
+    readonly cursor: "Opaque continuation value from next_cursor in the previous response. Keep the same prefix while paging. Omit for the first page.";
+    readonly limit: "Maximum number of assets per page. Defaults to 100 and accepts up to 500; follow next_cursor until null.";
+};
 /** Bounded metadata paging; cursors are the last returned, case-sensitive asset path. */
 export declare const damAssetsListOptionsSchema: z.ZodObject<{
     prefix: z.ZodDefault<z.ZodString>;

package/dist/v4/storageAsset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storageAsset.d.ts","sourceRoot":"","sources":["../../src/v4/storageAsset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAKvC,8EAA8E;AAC9E,eAAO,MAAM,YAAY,QAA+B,CAAA;AAExD,qEAAqE;AACrE,eAAO,MAAM,WAAW,aAG2D,CAAA;AAEnF,yFAAyF;AACzF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;iBAyB5B,CAAA;AAEF,iGAAiG;AACjG,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,yFAAyF;AACzF,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAA;AAEF,4FAA4F;AAC5F,eAAO,MAAM,wBAAwB;;iBAAmD,CAAA;AAExF,iFAAiF;AACjF,eAAO,MAAM,yBAAyB;;;iBAUpC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE9E,mFAAmF;AACnF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;kBAM7B,CAAA;AAEX,4FAA4F;AAC5F,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;kBAQ/B,CAAA;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAC5E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAChF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA"}
+{"version":3,"file":"storageAsset.d.ts","sourceRoot":"","sources":["../../src/v4/storageAsset.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAKvC,8EAA8E;AAC9E,eAAO,MAAM,YAAY,QAA+B,CAAA;AAExD,qEAAqE;AACrE,eAAO,MAAM,WAAW,aAIvB,CAAA;AAED,yFAAyF;AACzF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;iBA6C7B,CAAA;AAED,iGAAiG;AACjG,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,yFAAyF;AACzF,eAAO,MAAM,yBAAyB;;;;CAO5B,CAAA;AAEV,yFAAyF;AACzF,eAAO,MAAM,0BAA0B;;;;iBAUtC,CAAA;AAED,4FAA4F;AAC5F,eAAO,MAAM,wBAAwB;;iBAMnC,CAAA;AAEF,iFAAiF;AACjF,eAAO,MAAM,yBAAyB;;;iBASpC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE9E,mFAAmF;AACnF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;kBAM7B,CAAA;AAEX,4FAA4F;AAC5F,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;kBAQ/B,CAAA;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAC5E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAChF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

package/dist/v4/storageAsset.js

@@ -1,4 +1,6 @@
+import { optionalWithV3Semantics } from "./lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
+import { describeApiParameter, describeApiParameterFields } from "./apiParameterDescription.js";
 /** Maximum normalized Storage path length supported by the catalog schema. */
 export const damPathMaxCodePoints = 512;
 // A Unicode regexp counts code points and stays portable across the published Zod 3/4 schemas.
@@ -6,51 +8,64 @@ const boundedPathSchema = z.string().regex(new RegExp(`^[\\s\\S]{0,${damPathMaxC
 /** Canonical path and JSON representation of a 128-bit Storage identifier. */
 export const damIdPattern = /^[A-Za-z0-9_-]{21}[AQgw]$/u;
 /** Canonical public Storage asset, version and folder identifier. */
-export const damIdSchema = z
-    .string()
-    .regex(damIdPattern)
-    .describe('Case-sensitive, canonical 22-character Base64URL Storage identifier.');
+export const damIdSchema = describeApiParameter('damId', z.string().regex(damIdPattern), 'Case-sensitive, canonical 22-character Base64URL DAM identifier.');
 /** A retained version of a live Workspace asset, independent of its mutable location. */
-export const storedAssetSchema = z.object({
+export const storedAssetSchema = z.object(describeApiParameterFields('storedAsset', {
     workspace: z.string().min(1),
     asset_id: damIdSchema,
     version_id: damIdSchema,
     path: z.string().min(1),
     size: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
     mime: z.string().nullable(),
-    md5hash: z
+    md5hash: optionalWithV3Semantics(z
         .string()
-        .regex(/^[a-f0-9]{32}$/u)
-        .optional(),
-    sha256: z
+        .regex(/^[a-f0-9]{32}$/u)),
+    sha256: optionalWithV3Semantics(z
         .string()
-        .regex(/^[a-f0-9]{64}$/u)
-        .optional(),
-    width: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
-    height: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
-    thumbhash: z
+        .regex(/^[a-f0-9]{64}$/u)),
+    width: optionalWithV3Semantics(z.number().int().positive().max(Number.MAX_SAFE_INTEGER)),
+    height: optionalWithV3Semantics(z.number().int().positive().max(Number.MAX_SAFE_INTEGER)),
+    thumbhash: optionalWithV3Semantics(z
         .string()
-        .regex(/^(?:[A-Za-z0-9+/]{4}){1,15}(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)$/u)
-        .optional()
-        .describe('Base64-encoded ThumbHash of this version’s displayed pixels, when requested with output_meta.thumbhash on its producing Step. This is image data: apply the same access controls as the original.'),
-    has_alpha: z.boolean().optional().describe('Whether the image has an alpha channel, even if all its pixels are opaque. Present when ThumbHash extraction succeeds; absence means unknown.'),
-});
+        .regex(/^(?:[A-Za-z0-9+/]{4}){1,15}(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)$/u)),
+    has_alpha: optionalWithV3Semantics(z.boolean()),
+}, {
+    workspace: 'Workspace slug that owns this asset. Authenticate for the same Workspace when reading or managing it.',
+    asset_id: 'Stable asset ID. It survives native moves and renames; use it without a version to select the current bytes.',
+    version_id: 'Exact immutable version of this asset. Pair with asset_id to select retained bytes; a missing version never falls back to the current version.',
+    path: 'Current mutable location relative to the Workspace. A rename makes the previous path stale; overwriting can change the bytes at this path.',
+    size: 'Size of the stored file in bytes.',
+    mime: 'MIME type of the stored bytes, or null when unknown.',
+    md5hash: 'Lowercase MD5 checksum of the stored bytes, when available.',
+    sha256: 'Lowercase SHA-256 checksum of the stored bytes, when available.',
+    width: 'Display width in pixels, after applying EXIF orientation, when known.',
+    height: 'Display height in pixels, after applying EXIF orientation, when known.',
+    thumbhash: 'Base64-encoded ThumbHash of this version’s displayed pixels, when requested with output_meta.thumbhash on its producing Step. This is image data: apply the same access controls as the original.',
+    has_alpha: 'Whether the image has an alpha channel, even if all its pixels are opaque. Present when ThumbHash extraction succeeds; absence means unknown.',
+}));
+/** Shared explanations for portable client options and normalized API request fields. */
+export const damAssetsListDescriptions = {
+    prefix: 'Only list current asset paths starting with this case-sensitive prefix. The empty default includes the whole Workspace; include a trailing slash to select a directory boundary.',
+    cursor: 'Opaque continuation value from next_cursor in the previous response. Keep the same prefix while paging. Omit for the first page.',
+    limit: 'Maximum number of assets per page. Defaults to 100 and accepts up to 500; follow next_cursor until null.',
+};
 /** Bounded metadata paging; cursors are the last returned, case-sensitive asset path. */
-export const damAssetsListOptionsSchema = z.object({
+export const damAssetsListOptionsSchema = z.object(describeApiParameterFields('storedAssetsList', {
     prefix: boundedPathSchema.default(''),
-    cursor: boundedPathSchema.min(1).optional(),
+    cursor: optionalWithV3Semantics(boundedPathSchema.min(1)),
     limit: z.number().int().min(1).max(500).default(100),
-});
+}, damAssetsListDescriptions));
 /** An omitted version selects the current version; an explicit version never falls back. */
-export const damAssetGetOptionsSchema = z.object({ version_id: damIdSchema.optional() });
+export const damAssetGetOptionsSchema = z.object({
+    version_id: describeApiParameter('storedAssetGetVersionId', optionalWithV3Semantics(damIdSchema), 'Optional retained version of the selected asset. Omit for the current version. A missing or deleted version returns an error and never falls back to current bytes.'),
+});
 /** Omit the destination to rename in place; null moves to the Workspace root. */
 export const damAssetMoveOptionsSchema = z.object({
-    destination_folder_id: damIdSchema.nullable().optional(),
-    filename: z
+    destination_folder_id: optionalWithV3Semantics(damIdSchema.nullable()),
+    filename: optionalWithV3Semantics(z
         .string()
         .regex(/^[^/\\\p{Cc}]{1,255}$/u)
-        .refine((name) => name.trim() === name && name !== '.' && name !== '..', 'Use a filename, not a path')
-        .optional(),
+        .refine((name) => name.trim() === name && name !== '.' && name !== '..', 'Use a filename, not a path')),
 });
 /** Native metadata is the same version-pinned shape returned by storing a file. */
 export const damAssetFoundResponseSchema = z

package/dist/v4/storageResults.d.ts

@@ -0,0 +1,23 @@
+import type { StoredAsset } from './storageAsset.ts';
+import { z } from 'zod/v4';
+/** Server-owned Assembly identity and expected Workspace, never untrusted notification fields. */
+export declare const storedAssemblyResultsOptionsSchema: z.ZodObject<{
+    assemblyId: z.ZodString;
+    workspace: z.ZodString;
+}, z.core.$strip>;
+export type GetStoredAssemblyResultsOptions = z.infer<typeof storedAssemblyResultsOptionsSchema>;
+/** Canonical retained receipt and producing result provenance, for idempotent registration. */
+export interface StoredAssemblyResult {
+    assembly_id: string;
+    step: string;
+    result_id: string;
+    original_id?: string | (string | null)[];
+    asset: StoredAsset;
+}
+/**
+ * Pure extraction from a fetched/verified Assembly bound to an authorized app upload. Validates
+ * every retained result atomically; temporary outputs are ignored, partial receipts are rejected.
+ * This does not authenticate notifications or check application permissions.
+ */
+export declare function extractStoredAssemblyResults(input: unknown, options: GetStoredAssemblyResultsOptions): StoredAssemblyResult[];
+//# sourceMappingURL=storageResults.d.ts.map

package/dist/v4/storageResults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storageResults.d.ts","sourceRoot":"","sources":["../../src/v4/storageResults.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAO1B,kGAAkG;AAClG,eAAO,MAAM,kCAAkC;;;iBAG7C,CAAA;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAEhG,+FAA+F;AAC/F,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;IACxC,KAAK,EAAE,WAAW,CAAA;CACnB;AAaD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,+BAA+B,GACvC,oBAAoB,EAAE,CA6BxB"}