tripo-cli 0.7.2 → 0.8.0

package/dist/knowledge/models.js

@@ -1,9 +1,9 @@
 /**
- * Dual-model strategy — the single source of truth for 3D model selection.
+ * Model routing — the single source of truth for 3D generation selection.
  *
- * Rule (one branch, no exceptions): explicit low-poly intent or a face budget
- * <= 20000 selects P1; everything else selects v3.1. Explicit --model wins but
- * still goes through constraint validation.
+ * H3.1 is the official default (flagship, highest fidelity) and also covers dense
+ * geometry and H-only parameters. Real-time, editable and topology-constrained
+ * assets route to P2.
  */
 /**
  * Wire values are what the server actually accepts (backend whitelist:
@@ -13,24 +13,28 @@
  */
 export const MODEL_V31 = 'v3.1-20260211';
 export const MODEL_P1 = 'P1-20260311';
-/** P-series upgrade (Preview): adds quad output; explicit --model only, never auto-selected. */
+/** P-series model: editable low-poly topology and quad output. */
 export const MODEL_P2 = 'P2-20260801';
-/** User-facing aliases normalized to the wire values above. */
+/** User-facing aliases normalized to the wire values above (matched case-insensitively). */
 export const MODEL_ALIASES = {
+    'H3.1': MODEL_V31,
+    'P1.0': MODEL_P1,
+    'P2.0': MODEL_P2,
+    'P2.0 Preview': MODEL_P2,
     'v3.1': MODEL_V31,
     'v3.1-20260211': MODEL_V31,
     'tripo-v3.1': MODEL_V31,
-    p1: MODEL_P1,
     P1: MODEL_P1,
     'P1-20260311': MODEL_P1,
     'tripo-p1': MODEL_P1,
-    p2: MODEL_P2,
     P2: MODEL_P2,
     'P2-20260801': MODEL_P2,
     'tripo-p2': MODEL_P2,
     // Older whitelisted versions, alias → wire.
+    'H3.0': 'v3.0-20250812',
     'v3.0': 'v3.0-20250812',
     'tripo-v3.0': 'v3.0-20250812',
+    'H2.5': 'v2.5-20250123',
     'v2.5': 'v2.5-20250123',
     'tripo-v2.5': 'v2.5-20250123',
 };
@@ -52,6 +56,7 @@ export const P2_FORBIDDEN_PARAMS = ['smart_low_poly', 'generate_parts', 'geometr
 /** Rig wire versions (backend whitelist; marketing names rig-v1.0/rig-v2.0 are rejected). */
 export const RIG_MODEL_V1 = 'v1.0-20240301';
 export const RIG_MODEL_V25 = 'v2.5-20260210';
+export const RIG_MODEL_V30 = 'v3.0-20260909';
 /** Marketing rig names → wire versions the server actually accepts. */
 export const RIG_MODEL_ALIASES = {
     'rig-v1.0': RIG_MODEL_V1,
@@ -59,6 +64,8 @@ export const RIG_MODEL_ALIASES = {
     'rig-v2.0': RIG_MODEL_V25,
     'rig-v2.5': RIG_MODEL_V25,
     'v2.5-20260210': RIG_MODEL_V25,
+    'rig-v3.0': RIG_MODEL_V30,
+    'v3.0-20260909': RIG_MODEL_V30,
 };
 export function normalizeRigModel(input) {
     return RIG_MODEL_ALIASES[input] ?? input;
@@ -67,8 +74,9 @@ export function normalizeRigModel(input) {
 export const CAPABILITY_DEFAULTS = {
     texture: 'v3.0-20250812',
     /** Server default is v1.0 (biped-only presets); the CLI defaults to the
-     *  v2.5 rig which has presets for all seven body types. */
-    rig: RIG_MODEL_V25,
+     *  v3.0 rig: recommended for humanoids, v2.5 behavior and presets for the
+     *  other body types. */
+    rig: RIG_MODEL_V30,
     segment: 'v1.0-20250506',
     textToImage: 'seedream_v4',
     imageToImage: 'seedream_v5',
@@ -81,8 +89,18 @@ export const RIG_TYPES = [
     'avian',
     'serpentine',
     'aquatic',
+    'others',
 ];
-export const RIG_SPECS = ['tripo', 'mixamo'];
+/** Bone naming specs (biped only); actorcore/unity/unreal/vrm need rig v3.0. */
+export const RIG_SPECS = ['tripo', 'mixamo', 'actorcore', 'unity', 'unreal', 'vrm'];
+/** Retarget presets of non-biped rig types (rig v2.5/v3.0); avian and others have none. */
+export const NON_BIPED_PRESETS = {
+    quadruped: ['preset:quadruped:walk'],
+    hexapod: ['preset:hexapod:walk'],
+    octopod: ['preset:octopod:walk'],
+    serpentine: ['preset:serpentine:march'],
+    aquatic: ['preset:aquatic:march'],
+};
 /** Per-endpoint image model whitelists (ImageGenerationValidation):
  *  image-to-image does NOT accept seedream_v4. */
 export const TEXT_TO_IMAGE_MODELS = [
@@ -91,21 +109,25 @@ export const TEXT_TO_IMAGE_MODELS = [
     'banana',
     'banana_pro',
     'banana2',
-    'chat_image_1',
     'chat_image_1.5',
     'chat_image_2',
+    'chat_image_2.5_flare',
+    'chat_image_2.5_sunburst',
 ];
 export const IMAGE_TO_IMAGE_MODELS = [
     'seedream_v5',
     'banana',
     'banana_pro',
     'banana2',
-    'chat_image_1',
     'chat_image_1.5',
     'chat_image_2',
+    'chat_image_2.5_flare',
+    'chat_image_2.5_sunburst',
 ];
+/** Texture model required by texture_quality=fast and delight. */
+export const TEXTURE_MODEL_V35 = 'v3.5-20260815';
 /** texture_model whitelist (ModelPostProcessValidation.ALLOWED_TEXTURE_MODELS). */
-export const TEXTURE_MODELS = ['v3.0-20250812', 'v2.5-20250123'];
+export const TEXTURE_MODELS = [TEXTURE_MODEL_V35, 'v3.0-20250812', 'v2.5-20250123'];
 /** mesh_segmentation whitelist (ALLOWED_SEGMENT_MODELS). */
 export const SEGMENT_MODELS = ['v1.0-20250506', 'v2.0-20260430'];
 /** mesh/decimate whitelist (ALLOWED_DECIMATE_MODELS; blank/"default" → server default v2.0). */
@@ -137,12 +159,14 @@ export const TEXTURE_FORMATS = [
     'TIFF',
     'WEBP',
 ];
-export const FBX_PRESETS = ['blender', '3dsmax', 'mixamo'];
+export const FBX_PRESETS = ['blender', '3dsmax', 'mixamo', 'bake_scale'];
 export const EXPORT_ORIENTATIONS = ['+x', '-x', '+y', '-y'];
-export const TEXTURE_QUALITIES = ['standard', 'detailed', 'extreme'];
-/** Normalize any accepted alias to the canonical wire value; unknown values pass through. */
+/** `fast` only works with texture model v3.5 (other versions → 1004). */
+export const TEXTURE_QUALITIES = ['fast', 'standard', 'detailed', 'extreme'];
+const MODEL_ALIAS_LOOKUP = new Map(Object.entries(MODEL_ALIASES).map(([alias, wire]) => [alias.toLowerCase(), wire]));
+/** Normalize any accepted alias to the canonical wire value; unknown values pass through for validation to reject. */
 export function normalizeModel(input) {
-    return MODEL_ALIASES[input] ?? input;
+    return MODEL_ALIAS_LOOKUP.get(input.trim().toLowerCase()) ?? input;
 }
 export function isP1(model) {
     return normalizeModel(model) === MODEL_P1;
@@ -150,21 +174,117 @@ export function isP1(model) {
 export function isP2(model) {
     return normalizeModel(model) === MODEL_P2;
 }
-/** The one rule. Returns the model plus a human-readable reason. */
+function hRequirement(intent) {
+    const params = intent.params ?? {};
+    const quad = intent.quad === true || params.quad === true;
+    if (intent.denseGeometry)
+        return 'dense geometry';
+    if (params.geometry_quality !== undefined)
+        return 'geometry_quality';
+    if (params.smart_low_poly === true)
+        return 'smart_low_poly';
+    if (params.generate_parts === true)
+        return 'generate_parts';
+    if (typeof intent.faceLimit === 'number' && intent.faceLimit > (quad ? P2_FACE_LIMIT.quadMax : P2_FACE_LIMIT.triMax)) {
+        return `face budget exceeds P2 ${quad ? 'quad' : 'triangle'} limit`;
+    }
+    if (typeof intent.faceLimit === 'number' && intent.faceLimit > 0 && intent.faceLimit < P2_FACE_LIMIT.min) {
+        return 'face budget below P2 minimum';
+    }
+    return undefined;
+}
+/** Select a generation model from explicit choice, geometry requirements and intended use. */
 export function chooseModel(intent) {
-    if (intent.explicit) {
-        return { model: normalizeModel(intent.explicit), reason: 'explicit --model' };
+    const paramModel = typeof intent.params?.model === 'string' ? intent.params.model : undefined;
+    const explicit = intent.explicit ?? paramModel;
+    if (explicit) {
+        return {
+            model: normalizeModel(explicit),
+            reason: intent.explicit ? 'explicit --model' : 'explicit model parameter',
+        };
     }
-    if (intent.lowPoly) {
-        return { model: MODEL_P1, reason: 'low-poly intent → P1' };
+    const hOnly = hRequirement(intent);
+    if (hOnly) {
+        return { model: MODEL_V31, reason: `${hOnly} → v3.1` };
     }
-    if (intent.faceLimit !== undefined && intent.faceLimit <= P1_FACE_LIMIT.max) {
-        return { model: MODEL_P1, reason: `face budget ${intent.faceLimit} ≤ ${P1_FACE_LIMIT.max} → P1` };
+    if (intent.preferred) {
+        const preferred = normalizeModel(intent.preferred);
+        if (preferred !== MODEL_P1)
+            return { model: preferred, reason: 'scenario preference' };
+    }
+    const params = intent.params ?? {};
+    if (intent.lowPoly || intent.realtime || intent.editable || intent.quad === true || params.quad === true || intent.faceLimit !== undefined) {
+        return { model: MODEL_P2, reason: 'real-time or editable topology → P2' };
+    }
+    return { model: MODEL_V31, reason: 'official default → v3.1' };
+}
+/**
+ * Official list price per generation task in credits, identical on the ov and cn
+ * model pages. Tiers: [no texture, standard/fast, detailed, extreme]. P1 and the
+ * legacy models publish no price, so they are never estimated.
+ */
+const GENERATION_CREDITS = {
+    [MODEL_V31]: {
+        text_to_model: [10, 20, 30, 40],
+        image_to_model: [20, 30, 40, 50],
+        multiview_to_model: [20, 30, 40, 50],
+    },
+    [MODEL_P2]: {
+        text_to_model: [100, 110, 120, 130],
+        image_to_model: [100, 110, 120, 130],
+        multiview_to_model: [100, 110, 120, 130],
+    },
+};
+/** List-price credits for one generation task from its validated payload; undefined when no price is published. */
+export function estimateGenerationCredits(model, taskType, params) {
+    const wire = normalizeModel(model);
+    const tiers = GENERATION_CREDITS[wire]?.[taskType];
+    if (!tiers)
+        return undefined;
+    let credits = tiers[params.texture === false ? 0 : params.texture_quality === 'extreme' ? 3 : params.texture_quality === 'detailed' ? 2 : 1];
+    if (wire === MODEL_V31) {
+        if (params.geometry_quality === 'detailed')
+            credits += 20;
+        if (params.quad === true)
+            credits += 5;
+        if (params.smart_low_poly === true)
+            credits += 10;
+        if (params.generate_parts === true)
+            credits += 20;
     }
-    return { model: MODEL_V31, reason: 'default high-fidelity → v3.1' };
+    return credits;
 }
 /** Keywords that signal low-poly intent in a prompt (used by make/ai). */
-const LOW_POLY_HINTS = [/low[\s_-]?poly/i, /低模/, /低面/, /手游/, /voxel/i, /像素风/];
+const LOW_POLY_HINTS = [/low[\s_-]?poly/i, /低模/, /低面/, /低多边形/, /手游/, /voxel/i, /像素风/];
+/** Physical games, product nouns (gaming PC, console) and animation *styles* are not real-time intent. */
+const REALTIME_HINTS = [
+    /\b(?:(?<!\b(?:board|card|tabletop|dice|party)[\s_-]?)games?|gameplay|real[\s_-]?time|unity|unreal(?:\s+engine)?|godot|three\.?js|webgl)\b/i,
+    /\b(?:editable|edit[\s_-]?friendly|topology|retopo(?:logy)?|quad(?:s)?|rig(?:[\s_-]?ready|ged|ging)?|animat(?:e|ions?)(?![\s_-]?styl))\b/i,
+    /(?<!棋盘|桌面)游戏|手游|端游|实时|引擎|可编辑|可修改|拓扑|重拓扑|四边面|四边形|绑定|骨骼|动画(?![风片])|虚幻/,
+];
+const DENSE_GEOMETRY_HINTS = [
+    /\b(?:dense|high[\s_-]?density|high[\s_-]?detail(?:ed)?)\s+(?:mesh|geometry|topology)\b/i,
+    /\bhigh[\s_-]?poly(?:gon(?:al)?)?\b/i,
+    /\bnanite\b/i,
+    /\b(?:million|millions)\s+of\s+(?:faces|triangles|polygons)\b/i,
+    /高模|高面数|高多边形|高密度(?:网格|几何)|密集(?:网格|几何)|稠密(?:网格|几何)|高精度(?:网格|几何)|百万(?:面|三角面)/,
+];
 export function detectLowPolyIntent(text) {
     return LOW_POLY_HINTS.some((re) => re.test(text));
 }
+/** Detect uses that benefit from P-series topology without treating visual quality as mesh density. */
+export function detectRealtimeIntent(text) {
+    return REALTIME_HINTS.some((re) => re.test(text));
+}
+/** Detect only explicit dense-geometry requirements; phrases such as "high quality" do not match. */
+export function detectDenseGeometryIntent(text) {
+    // Match each mention independently: negating one must not hide a later positive requirement.
+    return DENSE_GEOMETRY_HINTS.some((re) => Array.from(text.matchAll(new RegExp(re.source, `${re.flags}g`))).some((match) => {
+        const before = text.slice(0, match.index);
+        const after = text.slice(match.index + match[0].length);
+        const negatedBefore = /(?:\b(?:no|not|without|avoid|exclude)\s+(?:(?:a|an|any|the)\s+)?|\b(?:do\s+not|don't|does\s+not|doesn't)\s+(?:need|want|require|use)\s+(?:(?:a|an|any|the)\s+)?|\bno\s+need\s+for\s+(?:(?:a|an|any|the)\s+)?|(?:不要|不需要|无需|不用|不使用|避免|非)\s*)$/i.test(before);
+        const negatedAfter = /^\s*(?:(?:mesh|geometry|topology)\s+)?(?:is\s+not|isn't|not)\s+(?:needed|required|wanted)\b/i.test(after)
+            || /^\s*(?:不需要|不要|无需)/.test(after);
+        return !negatedBefore && !negatedAfter;
+    }));
+}

package/dist/knowledge/params.js

@@ -5,14 +5,96 @@
  * Every rule here prevents a guaranteed 400 or a silently wasted credit.
  * Rules marked [hard] mirror server enforcement; [soft] are CLI smart defaults.
  */
-import { CONVERT_FORMATS, DECIMATE_MODELS, EXPORT_ORIENTATIONS, FBX_PRESETS, MODEL_P2, P1_FACE_LIMIT, P1_FORBIDDEN_PARAMS, P2_FACE_LIMIT, P2_FORBIDDEN_PARAMS, TEXTURE_FORMATS, TEXTURE_QUALITIES, isP1, isP2, normalizeModel, } from './models.js';
+import { CAPABILITY_DEFAULTS, IMAGE_TO_IMAGE_MODELS, TEXT_TO_IMAGE_MODELS, CONVERT_FORMATS, DECIMATE_MODELS, EXPORT_ORIENTATIONS, FBX_PRESETS, LEGACY_3D_MODELS, MODEL_P1, MODEL_P2, MODEL_V31, P1_FACE_LIMIT, P1_FORBIDDEN_PARAMS, P2_FACE_LIMIT, P2_FORBIDDEN_PARAMS, TEXTURE_FORMATS, TEXTURE_MODEL_V35, TEXTURE_QUALITIES, isP1, isP2, normalizeModel, } from './models.js';
 const PROMPT_MAX = 1024;
 const NEGATIVE_PROMPT_MAX = 255;
+/** Image endpoint contracts; never silently substitute a paid model. */
+export function validateImageParams(input, editing) {
+    const params = { ...input };
+    const warnings = [];
+    const errors = [];
+    const model = params.model === undefined
+        ? (editing ? CAPABILITY_DEFAULTS.imageToImage : CAPABILITY_DEFAULTS.textToImage)
+        : params.model;
+    params.model = model;
+    const models = editing ? IMAGE_TO_IMAGE_MODELS : TEXT_TO_IMAGE_MODELS;
+    if (model === 'chat_image_1') {
+        errors.push('model chat_image_1 retired on 2026-10-23; explicitly choose chat_image_2 or chat_image_2.5_flare/sunburst (no automatic resubmission)');
+    }
+    else if (!models.includes(model)) {
+        errors.push(`unsupported image model "${String(model)}" for ${editing ? 'image-to-image' : 'text-to-image'}`);
+    }
+    const chat25 = model === 'chat_image_2.5_flare' || model === 'chat_image_2.5_sunburst';
+    if (params.size !== undefined && typeof model === 'string' && !validImageSize(model, params.size)) {
+        errors.push(`size is unsupported for model ${model}`);
+    }
+    if ((model === 'seedream_v4' || model === 'seedream_v5') && typeof params.size === 'string' && params.size.includes('x')) {
+        warnings.push('Seedream exact pixel-count limits unverified: official MP ranges are rounded; server validation still applies');
+    }
+    if (params.quality !== undefined) {
+        const qualities = chat25 ? ['low', 'medium', 'high', 'xhigh', 'max']
+            : model === 'chat_image_2' ? ['low', 'medium', 'high'] : [];
+        if (!qualities.includes(params.quality))
+            errors.push(`quality is unsupported for model ${String(model)} (auto is not supported)`);
+    }
+    if (params.output_format !== undefined && !['png', 'jpeg'].includes(params.output_format)) {
+        errors.push('output_format must be png or jpeg');
+    }
+    if (params.background !== undefined) {
+        if (!chat25) {
+            delete params.background;
+            warnings.push('background is ignored outside chat_image_2.5 models (removed)');
+        }
+        else if (!['auto', 'opaque', 'transparent'].includes(params.background)) {
+            errors.push('background must be auto, opaque or transparent');
+        }
+        else if (params.background === 'transparent' && params.output_format !== undefined && params.output_format !== 'png') {
+            errors.push('background=transparent requires output_format=png');
+        }
+    }
+    return { params, warnings, errors };
+}
+/** Only documented size rules; rounded Seedream MP limits are not exact pixel thresholds. */
+function validImageSize(model, size) {
+    if (typeof size !== 'string')
+        return false;
+    const match = /^([1-9]\d*)x([1-9]\d*)$/.exec(size);
+    const w = Number(match?.[1]);
+    const h = Number(match?.[2]);
+    const pixels = !!match && Number.isSafeInteger(w) && Number.isSafeInteger(h);
+    if (model === 'banana') {
+        return ['1024x1024', '832x1248', '1248x832', '864x1184', '1184x864', '896x1152', '1152x896', '768x1344', '1344x768', '1536x672'].includes(size);
+    }
+    if (model === 'banana2')
+        return ['0.5K', '1K', '2K', '4K'].includes(size);
+    if (model === 'banana_pro')
+        return ['1K', '2K', '4K'].includes(size) || pixels;
+    if (model === 'seedream_v4' || model === 'seedream_v5') {
+        return ['2K', model === 'seedream_v5' ? '3K' : '4K'].includes(size) || (pixels && w / h >= 1 / 16 && w / h <= 16);
+    }
+    if (model === 'chat_image_1.5')
+        return ['1024x1024', '1024x1536', '1536x1024', 'auto'].includes(size);
+    if (model === 'chat_image_2' || model.startsWith('chat_image_2.5_')) {
+        return size === 'auto' || (pixels && w <= 3840 && h <= 3840 && w % 16 === 0 && h % 16 === 0 &&
+            Math.max(w, h) <= 3 * Math.min(w, h) && w * h >= 655360 && w * h <= 8294400);
+    }
+    return true; // Unknown models are rejected separately.
+}
+function validateFaceLimit(params, errors) {
+    if (params.face_limit !== undefined &&
+        (typeof params.face_limit !== 'number' || !Number.isFinite(params.face_limit) || !Number.isInteger(params.face_limit))) {
+        errors.push('face_limit must be a finite integer');
+    }
+}
 /** Validate + auto-fix parameters for 3D generation (text/image/multiview-to-model). */
 export function validateGenerationParams(model, input) {
     const params = { ...input };
     const warnings = [];
     const errors = [];
+    if (![MODEL_V31, MODEL_P1, MODEL_P2, ...LEGACY_3D_MODELS].includes(normalizeModel(model))) {
+        errors.push(`unsupported 3D model "${model}"`);
+    }
+    validateFaceLimit(params, errors);
     if (typeof params.prompt === 'string' && params.prompt.length > PROMPT_MAX) {
         errors.push(`prompt exceeds ${PROMPT_MAX} characters (${params.prompt.length})`);
     }
@@ -44,10 +126,16 @@ export function validateGenerationParams(model, input) {
         params.texture = true;
         warnings.push('pbr=true forces texture=true (adjusted)');
     }
-    // [hard] generate_parts outputs bare geometry: texture/pbr/quad must be off.
+    // [hard] pbr defaults to true server-side, so texture=false alone would still be textured.
+    if (params.texture === false && params.pbr === undefined) {
+        params.pbr = false;
+        warnings.push('texture=false implies pbr=false (adjusted)');
+    }
+    // [hard] generate_parts outputs bare geometry: texture/pbr/quad must be off
+    // (texture and pbr default to true server-side, so omitting them counts as on).
     if (params.generate_parts === true) {
         for (const key of ['texture', 'pbr', 'quad']) {
-            if (params[key] === true) {
+            if (key === 'quad' ? params[key] === true : params[key] !== false) {
                 params[key] = false;
                 warnings.push(`generate_parts=true disables ${key} (adjusted; run "tripo model texture" afterwards)`);
             }
@@ -59,7 +147,7 @@ export function validateGenerationParams(model, input) {
         if (typeof face === 'number') {
             if (face < P1_FACE_LIMIT.min || face > P1_FACE_LIMIT.max) {
                 errors.push(`P1 face_limit must be within ${P1_FACE_LIMIT.min}–${P1_FACE_LIMIT.max} (got ${face}); ` +
-                    `use tripo-v3.1 for higher budgets`);
+                    `use tripo-v3.1 for budgets outside this range`);
             }
         }
     }
@@ -71,7 +159,7 @@ export function validateGenerationParams(model, input) {
             const max = quad ? P2_FACE_LIMIT.quadMax : P2_FACE_LIMIT.triMax;
             if (face < P2_FACE_LIMIT.min || face > max) {
                 errors.push(`P2 face_limit must be within ${P2_FACE_LIMIT.min}–${max}${quad ? ' with quad=true' : ''} (got ${face}); ` +
-                    `use tripo-v3.1 for higher budgets`);
+                    `use tripo-v3.1 for budgets outside this range`);
             }
         }
     }
@@ -84,21 +172,44 @@ export function validateGenerationParams(model, input) {
             }
         }
     }
-    if (params.texture_quality !== undefined &&
-        !TEXTURE_QUALITIES.includes(params.texture_quality)) {
-        errors.push(`texture_quality must be one of ${TEXTURE_QUALITIES.join('/')}`);
-    }
+    applyTextureV35(params, 'texture_version', warnings, errors);
     // [hard] quad topology cannot be stored in GLB → output will be FBX.
     if (params.quad === true) {
         warnings.push('quad=true forces FBX output (quad topology cannot be stored in GLB)');
     }
     return { params, warnings, errors };
 }
+/**
+ * [hard] texture_quality=fast and delight only exist on texture model v3.5:
+ * fast on any other version is a 1004, delight is silently ignored. v3.5 is
+ * selected when no version was given. `key` is `texture_version` on the
+ * generation endpoints and `model` on /v3/models/texture.
+ */
+export function applyTextureV35(params, key, warnings, errors) {
+    if (params.texture_quality !== undefined && !TEXTURE_QUALITIES.includes(params.texture_quality)) {
+        errors.push(`texture_quality must be one of ${TEXTURE_QUALITIES.join('/')}`);
+    }
+    const feature = params.texture_quality === 'fast' ? 'texture_quality=fast' : params.delight !== undefined ? 'delight' : undefined;
+    if (!feature)
+        return;
+    const version = params[key];
+    if (version === undefined) {
+        params[key] = TEXTURE_MODEL_V35;
+        warnings.push(`${feature} needs ${key}=${TEXTURE_MODEL_V35} (selected)`);
+    }
+    else if (version !== TEXTURE_MODEL_V35) {
+        if (feature === 'delight')
+            warnings.push(`delight is ignored unless ${key}=${TEXTURE_MODEL_V35}`);
+        else
+            errors.push(`texture_quality=fast requires ${key}=${TEXTURE_MODEL_V35} (got "${String(version)}")`);
+    }
+}
 /** Validate parameters for models/convert. */
 export function validateConvertParams(input) {
     const params = { ...input };
     const warnings = [];
     const errors = [];
+    validateFaceLimit(params, errors);
     const format = typeof params.format === 'string' ? params.format.toUpperCase() : undefined;
     if (!format) {
         errors.push(`convert requires format (${CONVERT_FORMATS.join('/')})`);
@@ -109,9 +220,12 @@ export function validateConvertParams(input) {
     else {
         params.format = format;
     }
-    // [hard] quad topology cannot live in GLTF/GLB.
+    // [hard] quad topology cannot live in GLTF/GLB; quad output is always FBX.
     if (params.quad === true && format === 'GLTF') {
-        errors.push('quad=true cannot export GLTF (quad topology is not storable in glTF); use FBX/OBJ/USDZ');
+        errors.push('quad=true cannot export GLTF (quad topology is not storable in glTF); quad forces FBX output — use format=FBX');
+    }
+    else if (params.quad === true && format && format !== 'FBX') {
+        warnings.push(`quad=true forces FBX output (format ${format} is overridden)`);
     }
     if (params.force_symmetry === true && params.quad !== true) {
         delete params.force_symmetry;
@@ -142,30 +256,26 @@ export function validateConvertParams(input) {
         !EXPORT_ORIENTATIONS.includes(params.export_orientation)) {
         errors.push(`export_orientation must be one of ${EXPORT_ORIENTATIONS.join('/')}`);
     }
-    // [soft] cost transparency: any non-default option upgrades billing to
-    // convert_model_complex.
-    const defaults = {
-        texture_size: 4096,
-        texture_format: 'JPEG',
-        bake: true,
-        pack_uv: false,
-        export_vertex_colors: false,
-        pivot_to_center_bottom: false,
-        scale_factor: 1,
-        with_animation: true,
-        animate_in_place: false,
-        export_orientation: '+x',
-        fbx_preset: 'blender',
-        quad: false,
-        flatten_bottom: false,
-        force_symmetry: false,
-    };
-    const complex = Object.entries(defaults).some(([k, dv]) => params[k] !== undefined && params[k] !== dv) || params.face_limit !== undefined || params.part_names !== undefined;
-    if (complex) {
+    // [soft] cost transparency.
+    if (isComplexConvert(params)) {
         warnings.push('non-default convert options use the "complex convert" price tier');
     }
     return { params, warnings, errors };
 }
+/** Pricing page: a non-default value of any of these (or any face_limit) bills the complex convert tier. */
+const COMPLEX_CONVERT_DEFAULTS = {
+    quad: false,
+    flatten_bottom: false,
+    flatten_bottom_threshold: 0.01,
+    texture_size: 4096,
+    texture_format: 'JPEG',
+    pivot_to_center_bottom: false,
+    scale_factor: 1,
+};
+export function isComplexConvert(params) {
+    return (params.face_limit !== undefined ||
+        Object.entries(COMPLEX_CONVERT_DEFAULTS).some(([k, dv]) => params[k] !== undefined && String(params[k]).toUpperCase() !== String(dv).toUpperCase()));
+}
 /**
  * Validate parameters for mesh/decimate (ModelPostProcessValidation):
  * v2.0 (default) / v3.0: face_limit 500–20000 tri / 500–10000 quad.
@@ -176,6 +286,7 @@ export function validateDecimateParams(input) {
     const params = { ...input };
     const warnings = [];
     const errors = [];
+    validateFaceLimit(params, errors);
     const model = typeof params.model === 'string' ? params.model.toLowerCase() : undefined;
     if (model !== undefined && model !== 'default' && !DECIMATE_MODELS.includes(model)) {
         errors.push(`decimate model must be ${DECIMATE_MODELS.join('/')} (got "${String(params.model)}")`);
@@ -184,7 +295,7 @@ export function validateDecimateParams(input) {
     if (params.smart_uv === true) {
         if (model === undefined) {
             params.model = 'v3.0';
-            warnings.push('smart_uv requires decimate v3.0: using model=v3.0 (35 credits tri / 40 quad; v2.0 is 30)');
+            warnings.push('smart_uv requires decimate v3.0: using model=v3.0 (cost not estimated; check current regional pricing)');
         }
         else if (model !== 'v3.0') {
             errors.push(`smart_uv only works with decimate model v3.0 (got "${String(params.model)}")`);