@remixmate/cli 0.9.6 → 0.9.8

package/README.md

@@ -188,6 +188,29 @@ npm run smoke
 # CLI unit tests (argv parser + skill schema)
 npm run test:cli
 
+# ── Template regression (after changing binding / timeline / template code) ──
+# L1 (contracts) + L2 (render-plan golden snapshots), full coverage, seconds,
+# no render and no generation API calls. Run this before/after touching shared
+# template plumbing to catch "did I break some OTHER template's binding?".
+npm run regress
+
+# Accept intended render-plan changes (rewrites L2 baselines):
+npm run regress:update
+
+# Run only the render-plan snapshot layer:
+npm run test:render-plan
+
+# L3 — selective, real Remotion render of chosen template(s). NOT full-library
+# by design (rendering is slow + needs asset generation). Catches crashes /
+# black frames the static layers can't. Needs PRIV_TOKEN for narration TTS;
+# pass --stub-image-url to keep image-heavy renders cheap.
+npm run check:render -- --template spotlight-card --frame
+
+# Template defs come from the registry (ab-api HTTP + /tmp cache), exactly like
+# render_video in production. A warm cache or reachable ab-api is required.
+# In a multi-repo checkout the scripts auto-detect template-library; override
+# with AB_TEMPLATES_SRC=/path/to/template-library/packages/templates/src.
+
 # Python skills forward --help to the underlying script:
 remixmate gen-script --help
 remixmate prepare-video-assets --help

package/dist/capabilities.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Model capabilities client.
+ *
+ * The model roster — internal model ids, friendly aliases, defaults, and each
+ * model's parameter constraints (aspect ratios / resolutions / durations /
+ * reference-image caps / Seedream size presets) — is owned by ab-api and served
+ * from POST /model/capabilities (public, no auth). The CLI fetches it at runtime
+ * instead of hardcoding it, so this npm package never ships the internal model
+ * matrix or provider details, and validation can't drift from the backend.
+ *
+ * Fetched once per process and memoized; the catalog is static server-side.
+ */
+export interface ModelConstraints {
+    aspectRatios?: string[];
+    resolutions?: string[];
+    durations?: number[];
+    durationMin?: number;
+    durationMax?: number;
+    durationDefault?: number;
+    refImageMax?: number;
+    sizes?: string[];
+    /** aspect-ratio → [width, height] pixel preset (Seedream). */
+    sizePresets?: Record<string, [number, number]>;
+}
+export interface ModelDescriptor {
+    id: string;
+    label: string;
+    aliases?: string[];
+    default?: boolean;
+    constraints: ModelConstraints;
+}
+export interface VoiceCapabilities {
+    provider: string;
+    defaultVoiceId: string;
+    speedMin: number;
+    speedMax: number;
+}
+export interface DigitalHumanCapabilities {
+    sources: string[];
+    defaultVoiceId: string;
+}
+export interface ModelCapabilities {
+    image: ModelDescriptor[];
+    video: ModelDescriptor[];
+    voice: VoiceCapabilities;
+    digitalHuman: DigitalHumanCapabilities;
+}
+/** Fetch (and memoize) the model capabilities catalog from ab-api. */
+export declare function getCapabilities(apiBaseUrl?: string): Promise<ModelCapabilities>;
+/**
+ * Resolve a user-supplied model (friendly alias or full id) against a model
+ * list. Returns the matched descriptor, or null when nothing matches.
+ */
+export declare function matchModel(list: ModelDescriptor[], input: string): ModelDescriptor | null;
+/** The descriptor flagged `default` in a list, falling back to the first entry. */
+export declare function defaultModel(list: ModelDescriptor[]): ModelDescriptor | undefined;

package/dist/capabilities.js

@@ -0,0 +1,75 @@
+/**
+ * Model capabilities client.
+ *
+ * The model roster — internal model ids, friendly aliases, defaults, and each
+ * model's parameter constraints (aspect ratios / resolutions / durations /
+ * reference-image caps / Seedream size presets) — is owned by ab-api and served
+ * from POST /model/capabilities (public, no auth). The CLI fetches it at runtime
+ * instead of hardcoding it, so this npm package never ships the internal model
+ * matrix or provider details, and validation can't drift from the backend.
+ *
+ * Fetched once per process and memoized; the catalog is static server-side.
+ */
+import { resolveApiBaseUrl, SkillError } from './http.js';
+let cached = null;
+/** Fetch (and memoize) the model capabilities catalog from ab-api. */
+export async function getCapabilities(apiBaseUrl) {
+    if (cached)
+        return cached;
+    const base = resolveApiBaseUrl(apiBaseUrl);
+    const url = `${base}/model/capabilities`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 15_000);
+    let resp;
+    try {
+        resp = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: '{}',
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+            throw new SkillError(`❌ request timed out fetching model capabilities: ${url}`);
+        }
+        throw new SkillError(`❌ network error fetching model capabilities: ${err.message}`);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    const text = await resp.text();
+    if (!resp.ok) {
+        throw new SkillError(`❌ failed to fetch model capabilities (HTTP ${resp.status}): ${text}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new SkillError(`❌ model capabilities response is not JSON: ${text.slice(0, 200)}`);
+    }
+    if (parsed.code !== 0 || !parsed.data) {
+        throw new SkillError(`❌ model capabilities request failed: ${parsed.msg ?? 'unknown error'} (code=${parsed.code})`);
+    }
+    cached = parsed.data;
+    return cached;
+}
+/**
+ * Resolve a user-supplied model (friendly alias or full id) against a model
+ * list. Returns the matched descriptor, or null when nothing matches.
+ */
+export function matchModel(list, input) {
+    const key = input.trim().toLowerCase();
+    for (const m of list) {
+        if (m.id.toLowerCase() === key)
+            return m;
+        if ((m.aliases ?? []).some((a) => a.toLowerCase() === key))
+            return m;
+    }
+    return null;
+}
+/** The descriptor flagged `default` in a list, falling back to the first entry. */
+export function defaultModel(list) {
+    return list.find((m) => m.default) ?? list[0];
+}

package/dist/handlers/gen-digital-human.js

@@ -9,10 +9,9 @@
  * http.ts. Endpoints and payloads match the backend DigitalHumanVideoGenerateDTO.
  */
 import { mmPost, pollUntil, resolveHttpContext, SkillError } from '../http.js';
+import { getCapabilities } from '../capabilities.js';
 import { emitProgress } from '../progress.js';
 import { isTrue, toNumber } from './shared.js';
-const VALID_SOURCES = new Set(['jimeng', 'hifly']);
-const DEFAULT_VOICE_ID = 'male-qn-qingse';
 async function listAvatars(ctx, input) {
     const payload = { current: 1, pageSize: 100 };
     if (input.source)
@@ -51,10 +50,10 @@ async function fetchAvatarInfo(ctx, avatarId) {
     }
     throw new SkillError(`❌ avatar_id=${avatarId} not found; use --list-avatars [--mine] to see what is available`);
 }
-function resolveSource(explicit, avatar) {
+function resolveSource(explicit, avatar, validSources) {
     const src = (explicit ?? '').trim() || (avatar.source ?? '').trim();
-    if (!VALID_SOURCES.has(src)) {
-        throw new SkillError('❌ Could not determine a valid source (jimeng/hifly). Pass --source, or confirm the avatar carries a source field.');
+    if (!validSources.includes(src)) {
+        throw new SkillError(`❌ Could not determine a valid source (${validSources.join('/')}). Pass --source, or confirm the avatar carries a source field.`);
     }
     return src;
 }
@@ -117,9 +116,10 @@ export async function genDigitalHuman(input, ctxIn) {
             throw new SkillError('❌ in TTS mode provide --text, or use --audio-url for audio-driven mode');
         }
     }
+    const dh = (await getCapabilities(input.api_base_url)).digitalHuman;
     emitProgress({ phase: 'gen-digital-human:resolve-avatar', avatarId });
     const avatar = await fetchAvatarInfo(ctx, avatarId);
-    const source = resolveSource(input.source, avatar);
+    const source = resolveSource(input.source, avatar, dh.sources);
     const payload = { avatarId, source };
     if (audioUrl) {
         payload.audioUrl = audioUrl;
@@ -128,7 +128,7 @@ export async function genDigitalHuman(input, ctxIn) {
     }
     else {
         payload.text = text;
-        payload.voiceId = input.voice_id ?? DEFAULT_VOICE_ID;
+        payload.voiceId = input.voice_id ?? dh.defaultVoiceId;
         if (input.voice_name)
             payload.voiceName = String(input.voice_name);
     }

package/dist/handlers/gen-image.d.ts

@@ -1,13 +1,19 @@
 /**
  * gen-image handler — POST ab-api /model/genImg.
  *
- * Mirrors the previous `scripts/gen_image.py` behavior:
- *   - Seedream models accept width/height (via SIZE_PRESETS lookup or WxH parse)
- *   - Gemini models accept aspectRatio + size (1K/2K/4K)
- *   - Reference images: HTTPS URLs and data: URIs pass through; local paths
- *     are read and base64-encoded into a data: URI
+ * Thin forwarder: the model roster, defaults, size presets and reference-image
+ * caps all come from ab-api's capabilities catalog (see capabilities.ts), not
+ * from this package. Behavior:
+ *   - --model accepts a friendly alias or a full id; resolved against the catalog
+ *     (ab-api also resolves aliases server-side, so an unknown value still passes
+ *     through and is validated by the backend).
+ *   - --size accepts a WxH string (→ width/height) or an aspect-ratio preset key
+ *     (→ aspectRatio; for Seedream models ab-api maps the preset to pixels).
+ *   - --resolution maps to the Gemini `size` tier (1K/2K/4K); ignored by others.
+ *   - Reference images: HTTPS URLs and data: URIs pass through; local paths are
+ *     read and base64-encoded into a data: URI.
  *   - Async response (generationId + status:'generating'/'pending') is polled
- *     against /model/getImgStatus until completed/failed/timeout
+ *     against /model/getImgStatus until completed/failed/timeout.
  */
 import type { HandlerContext, HandlerInput } from './index.js';
 export declare function genImage(input: HandlerInput, ctxIn: HandlerContext): Promise<void>;

package/dist/handlers/gen-image.js

@@ -1,46 +1,24 @@
 /**
  * gen-image handler — POST ab-api /model/genImg.
  *
- * Mirrors the previous `scripts/gen_image.py` behavior:
- *   - Seedream models accept width/height (via SIZE_PRESETS lookup or WxH parse)
- *   - Gemini models accept aspectRatio + size (1K/2K/4K)
- *   - Reference images: HTTPS URLs and data: URIs pass through; local paths
- *     are read and base64-encoded into a data: URI
+ * Thin forwarder: the model roster, defaults, size presets and reference-image
+ * caps all come from ab-api's capabilities catalog (see capabilities.ts), not
+ * from this package. Behavior:
+ *   - --model accepts a friendly alias or a full id; resolved against the catalog
+ *     (ab-api also resolves aliases server-side, so an unknown value still passes
+ *     through and is validated by the backend).
+ *   - --size accepts a WxH string (→ width/height) or an aspect-ratio preset key
+ *     (→ aspectRatio; for Seedream models ab-api maps the preset to pixels).
+ *   - --resolution maps to the Gemini `size` tier (1K/2K/4K); ignored by others.
+ *   - Reference images: HTTPS URLs and data: URIs pass through; local paths are
+ *     read and base64-encoded into a data: URI.
  *   - Async response (generationId + status:'generating'/'pending') is polled
- *     against /model/getImgStatus until completed/failed/timeout
+ *     against /model/getImgStatus until completed/failed/timeout.
  */
 import { mmPost, pollUntil, resolveHttpContext, SkillError } from '../http.js';
+import { getCapabilities, matchModel, defaultModel } from '../capabilities.js';
 import { emitProgress } from '../progress.js';
 import { isTrue, resolveImageInput, toNumber, toStringArray } from './shared.js';
-const DEFAULT_IMAGE_MODEL = 'doubao/doubao-seedream-5-0-260128';
-// Maps aspect-ratio shorthand → (width, height) for Seedream models.
-const SIZE_PRESETS = {
-    '1:1': [2048, 2048],
-    '16:9': [2848, 1600],
-    '9:16': [1600, 2848],
-    '4:3': [2304, 1728],
-    '3:4': [1728, 2304],
-    '2:3': [1664, 2496],
-};
-// Per-model reference-image caps (matches ab-api validation).
-const SEEDREAM_REF_LIMIT = 14;
-const GEMINI_REF_LIMIT = 4;
-function isSeedreamModel(model) {
-    const lower = model.toLowerCase();
-    return lower.includes('seedream') || lower.includes('seedance');
-}
-/** Resolve {width, height} for Seedream from --size (preset key or WxH). */
-function resolveSeedreamSize(size) {
-    if (SIZE_PRESETS[size]) {
-        const [w, h] = SIZE_PRESETS[size];
-        return { width: w, height: h };
-    }
-    if (/^\d+x\d+$/i.test(size)) {
-        const [w, h] = size.toLowerCase().split('x').map((v) => parseInt(v, 10));
-        return { width: w, height: h };
-    }
-    throw new SkillError(`❌ Seedream model does not support size format: ${size} (use 1:1 / 9:16 / 16:9 ... or WxH like 1600x2848)`);
-}
 async function pollImageStatus(ctx, generationId) {
     return pollUntil(async () => {
         const data = await mmPost(ctx, '/model/getImgStatus', { generationId }, { timeoutMs: 30_000 });
@@ -61,11 +39,13 @@ export async function genImage(input, ctxIn) {
     if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
         throw new SkillError('❌ Please provide --prompt to describe the image');
     }
-    const ctx = await resolveHttpContext(ctxIn.skillName, {
-        apiBaseUrl: input.api_base_url,
-        privateToken: input.priv_token,
-    });
-    const model = input.model ?? process.env.MM_IMAGE_MODEL ?? DEFAULT_IMAGE_MODEL;
+    const apiBaseUrl = input.api_base_url;
+    const caps = await getCapabilities(apiBaseUrl);
+    // Resolve the model against the catalog: explicit alias/id, env override, or default.
+    const requested = input.model ?? process.env.MM_IMAGE_MODEL;
+    const descriptor = requested ? matchModel(caps.image, requested) : defaultModel(caps.image);
+    // Send the resolved id when known; otherwise forward the raw value for the backend to handle.
+    const model = descriptor?.id ?? requested ?? defaultModel(caps.image)?.id ?? '';
     const size = input.size ?? '1:1';
     const n = toNumber(input.n, 'n') ?? 1;
     const resolution = input.resolution ?? '1K';
@@ -77,11 +57,10 @@ export async function genImage(input, ctxIn) {
     // when ab-agent's buildCliArgs passes booleans, only the truthy flag appears.
     // Treat presence as true; explicit `--no-watermark` isn't supported here.
     const watermark = input.watermark === true ? true : undefined;
-    const seedream = isSeedreamModel(model);
     const references = toStringArray(input.reference).map(resolveImageInput).filter(Boolean);
-    const refLimit = seedream ? SEEDREAM_REF_LIMIT : GEMINI_REF_LIMIT;
-    if (references.length > refLimit) {
-        throw new SkillError(`❌ ${seedream ? 'Seedream' : 'Gemini'} model accepts at most ${refLimit} reference images, got ${references.length}`);
+    const refLimit = descriptor?.constraints.refImageMax;
+    if (refLimit !== undefined && references.length > refLimit) {
+        throw new SkillError(`❌ ${descriptor?.label ?? model} accepts at most ${refLimit} reference images, got ${references.length}`);
     }
     const payload = { model, prompt, imageCount: n };
     if (guidanceScale !== undefined)
@@ -96,13 +75,22 @@ export async function genImage(input, ctxIn) {
         payload.seed = seed;
     if (watermark !== undefined)
         payload.watermark = watermark;
-    if (seedream) {
-        Object.assign(payload, resolveSeedreamSize(size));
+    // --size as WxH → explicit pixels; otherwise treat as an aspect-ratio preset.
+    // ab-api maps an aspect-ratio preset to pixels for Seedream and uses it directly
+    // for Gemini, so the CLI carries no per-model size table.
+    if (/^\d+x\d+$/i.test(size)) {
+        const [w, h] = size.toLowerCase().split('x').map((v) => parseInt(v, 10));
+        payload.width = w;
+        payload.height = h;
     }
     else {
         payload.aspectRatio = size;
-        payload.size = resolution;
     }
+    payload.size = resolution;
+    const ctx = await resolveHttpContext(ctxIn.skillName, {
+        apiBaseUrl,
+        privateToken: input.priv_token,
+    });
     emitProgress({ phase: 'gen-image:request', model, size, n });
     const data = await mmPost(ctx, '/model/genImg', payload, { timeoutMs: 120_000 });
     let imageUrls = (data.imageUrls ?? []).filter((u) => !!u);

package/dist/handlers/gen-video.d.ts

@@ -1,15 +1,14 @@
 /**
  * gen-video handler — POST ab-api /model/genVideo, then poll /model/getVideoStatus.
  *
- * Ported from the previous `scripts/gen_video.py` (entry.type python →
- * entry.type http) so it shares auth / base-URL / business-code / polling with
- * the other atomic generators via http.ts instead of re-implementing them.
+ * Thin forwarder: the model roster, friendly aliases, defaults and per-model
+ * constraints (aspect ratios / resolutions / durations / reference-image caps)
+ * come from ab-api's capabilities catalog (see capabilities.ts), not from this
+ * package. Pre-flight validation here is purely data-driven from that catalog —
+ * the CLI carries no model matrix — and ab-api re-validates authoritatively.
  *
- * Model families (aligned with the ab-web AI_VIDEO_MODELS dropdown):
- *   - Seedance 1.5 Pro (Volcano): audio, first/last frame, fixed camera,
- *     adaptive ratio, duration 4–12s
- *   - Veo 3.1 / Veo 3.1 Fast (Google): first/last frame, reference images,
- *     negative prompt, 4K, duration 4/6/8s
+ * --model accepts a friendly alias or a full id; ab-api also resolves aliases
+ * server-side, so an unknown value still passes through to the backend.
  *
  * Local image paths for first/last/reference frames are read and base64-encoded
  * into a data: URI; https / data: URIs pass through unchanged.

package/dist/handlers/gen-video.js

@@ -1,79 +1,47 @@
 /**
  * gen-video handler — POST ab-api /model/genVideo, then poll /model/getVideoStatus.
  *
- * Ported from the previous `scripts/gen_video.py` (entry.type python →
- * entry.type http) so it shares auth / base-URL / business-code / polling with
- * the other atomic generators via http.ts instead of re-implementing them.
+ * Thin forwarder: the model roster, friendly aliases, defaults and per-model
+ * constraints (aspect ratios / resolutions / durations / reference-image caps)
+ * come from ab-api's capabilities catalog (see capabilities.ts), not from this
+ * package. Pre-flight validation here is purely data-driven from that catalog —
+ * the CLI carries no model matrix — and ab-api re-validates authoritatively.
  *
- * Model families (aligned with the ab-web AI_VIDEO_MODELS dropdown):
- *   - Seedance 1.5 Pro (Volcano): audio, first/last frame, fixed camera,
- *     adaptive ratio, duration 4–12s
- *   - Veo 3.1 / Veo 3.1 Fast (Google): first/last frame, reference images,
- *     negative prompt, 4K, duration 4/6/8s
+ * --model accepts a friendly alias or a full id; ab-api also resolves aliases
+ * server-side, so an unknown value still passes through to the backend.
  *
  * Local image paths for first/last/reference frames are read and base64-encoded
  * into a data: URI; https / data: URIs pass through unchanged.
  */
 import { mmPost, pollUntil, resolveHttpContext, SkillError } from '../http.js';
+import { getCapabilities, matchModel, defaultModel } from '../capabilities.js';
 import { emitProgress } from '../progress.js';
 import { isTrue, resolveImageInput, toNumber, toStringArray } from './shared.js';
-const DEFAULT_VIDEO_MODEL = 'doubao-seedance-1-5-pro-251215';
-// CLI shorthand → full LiteLLM / gateway model id (matches the frontend dropdown).
-const MODEL_ALIASES = {
-    seedance: 'doubao-seedance-1-5-pro-251215',
-    'seedance-1.5': 'doubao-seedance-1-5-pro-251215',
-    'seedance-1.5-pro': 'doubao-seedance-1-5-pro-251215',
-    veo: 'veo-3.1-generate-001',
-    'veo-3.1': 'veo-3.1-generate-001',
-    'veo-3.1-generate': 'veo-3.1-generate-001',
-    'veo-fast': 'veo-3.1-fast-generate-001',
-    'veo-3.1-fast': 'veo-3.1-fast-generate-001',
-    'veo-3.1-fast-generate': 'veo-3.1-fast-generate-001',
-};
-const SEEDANCE_RATIOS = new Set(['adaptive', '16:9', '4:3', '1:1', '3:4', '9:16', '21:9']);
-const SEEDANCE_RESOLUTIONS = new Set(['480p', '720p', '1080p']);
-const VEO_RATIOS = new Set(['16:9', '9:16']);
-const VEO_RESOLUTIONS = new Set(['720p', '1080p', '4k']);
-const VEO_DURATIONS = new Set([4, 6, 8]);
-const VEO_MAX_REFERENCE_IMAGES = 3;
-function normalizeModelId(model) {
-    const key = model.trim().toLowerCase();
-    return MODEL_ALIASES[key] ?? model.trim();
-}
-function isSeedanceModel(model) {
-    return model.toLowerCase().includes('seedance');
-}
-function isVeoModel(model) {
-    return model.toLowerCase().includes('veo');
-}
-function validateParamsForModel(model, duration, ratio, resolution, refCount) {
-    if (isSeedanceModel(model)) {
-        if (duration < 4 || duration > 12) {
-            throw new SkillError(`❌ Seedance duration must be 4–12 s, got: ${duration}`);
-        }
-        if (!SEEDANCE_RATIOS.has(ratio)) {
-            throw new SkillError(`❌ Seedance aspect ratio must be one of: ${[...SEEDANCE_RATIOS].join(', ')}; got: ${ratio}`);
-        }
-        if (!SEEDANCE_RESOLUTIONS.has(resolution)) {
-            throw new SkillError(`❌ Seedance resolution must be one of: ${[...SEEDANCE_RESOLUTIONS].join(', ')}; got: ${resolution}`);
-        }
-        if (refCount > 0) {
-            throw new SkillError('❌ Seedance 1.5 Pro does not support a reference-image array (first / last frame only); use --first-frame / --last-frame instead');
+/** Generic, catalog-driven validation. No model names live here. */
+function validateAgainstConstraints(descriptor, duration, ratio, resolution, refCount) {
+    const c = descriptor.constraints;
+    const label = descriptor.label || descriptor.id;
+    if (c.durations && c.durations.length > 0) {
+        if (!c.durations.includes(duration)) {
+            throw new SkillError(`❌ ${label} duration must be one of: ${c.durations.join(', ')} s; got: ${duration}`);
         }
     }
-    else if (isVeoModel(model)) {
-        if (!VEO_DURATIONS.has(duration)) {
-            throw new SkillError(`❌ Veo duration must be one of: ${[...VEO_DURATIONS].join(', ')} s; got: ${duration}`);
+    else if (c.durationMin !== undefined && c.durationMax !== undefined) {
+        if (duration < c.durationMin || duration > c.durationMax) {
+            throw new SkillError(`❌ ${label} duration must be ${c.durationMin}–${c.durationMax} s, got: ${duration}`);
         }
-        if (!VEO_RATIOS.has(ratio)) {
-            throw new SkillError(`❌ Veo aspect ratio must be one of: ${[...VEO_RATIOS].join(', ')}; got: ${ratio}`);
-        }
-        if (!VEO_RESOLUTIONS.has(resolution)) {
-            throw new SkillError(`❌ Veo resolution must be one of: ${[...VEO_RESOLUTIONS].join(', ')}; got: ${resolution}`);
-        }
-        if (refCount > VEO_MAX_REFERENCE_IMAGES) {
-            throw new SkillError(`❌ Veo accepts at most ${VEO_MAX_REFERENCE_IMAGES} reference images; got: ${refCount}`);
+    }
+    if (c.aspectRatios && c.aspectRatios.length > 0 && !c.aspectRatios.includes(ratio)) {
+        throw new SkillError(`❌ ${label} aspect ratio must be one of: ${c.aspectRatios.join(', ')}; got: ${ratio}`);
+    }
+    if (c.resolutions && c.resolutions.length > 0 && !c.resolutions.includes(resolution)) {
+        throw new SkillError(`❌ ${label} resolution must be one of: ${c.resolutions.join(', ')}; got: ${resolution}`);
+    }
+    if (c.refImageMax !== undefined && refCount > c.refImageMax) {
+        if (c.refImageMax === 0) {
+            throw new SkillError(`❌ ${label} does not support a reference-image array; use --first-frame / --last-frame instead`);
         }
+        throw new SkillError(`❌ ${label} accepts at most ${c.refImageMax} reference images; got: ${refCount}`);
     }
 }
 async function pollVideoStatus(ctx, taskId) {
@@ -92,7 +60,12 @@ async function pollVideoStatus(ctx, taskId) {
     }, { intervalMs: 10_000, timeoutMs: 300_000 });
 }
 export async function genVideo(input, ctxIn) {
-    const model = normalizeModelId(input.model ?? process.env.MM_VIDEO_MODEL ?? DEFAULT_VIDEO_MODEL);
+    const apiBaseUrl = input.api_base_url;
+    const caps = await getCapabilities(apiBaseUrl);
+    // Resolve the model against the catalog: explicit alias/id, env override, or default.
+    const requested = input.model ?? process.env.MM_VIDEO_MODEL;
+    const descriptor = requested ? matchModel(caps.video, requested) : defaultModel(caps.video);
+    const model = descriptor?.id ?? requested ?? defaultModel(caps.video)?.id ?? '';
     const firstFrame = input.first_frame ? resolveImageInput(String(input.first_frame)) : '';
     const lastFrame = input.last_frame ? resolveImageInput(String(input.last_frame)) : '';
     const references = toStringArray(input.reference).map(resolveImageInput).filter(Boolean);
@@ -103,11 +76,14 @@ export async function genVideo(input, ctxIn) {
     }
     const ratio = input.ratio ?? '16:9';
     const resolution = input.resolution ?? '720p';
-    const duration = toNumber(input.duration, 'duration') ?? (isVeoModel(model) ? 8 : 5);
+    const duration = toNumber(input.duration, 'duration') ?? descriptor?.constraints.durationDefault ?? 5;
     const seed = toNumber(input.seed, 'seed');
-    validateParamsForModel(model, duration, ratio, resolution, references.length);
+    // Pre-flight validation only when we recognize the model (have its constraints).
+    if (descriptor) {
+        validateAgainstConstraints(descriptor, duration, ratio, resolution, references.length);
+    }
     const ctx = await resolveHttpContext(ctxIn.skillName, {
-        apiBaseUrl: input.api_base_url,
+        apiBaseUrl,
         privateToken: input.priv_token,
     });
     const payload = {

package/dist/handlers/gen-voice.d.ts

@@ -1,5 +1,5 @@
 /**
- * gen-voice handler — Minimax TTS via ab-api /tool/minimaxT2aV2.
+ * gen-voice handler — Minimax TTS via ab-api unified /tool/tts (provider=minimax).
  *
  * Operations:
  *   --list-voices true                 → GET available voice IDs from /voice/page (live)

package/dist/handlers/gen-voice.js

@@ -1,5 +1,5 @@
 /**
- * gen-voice handler — Minimax TTS via ab-api /tool/minimaxT2aV2.
+ * gen-voice handler — Minimax TTS via ab-api unified /tool/tts (provider=minimax).
  *
  * Operations:
  *   --list-voices true                 → GET available voice IDs from /voice/page (live)
@@ -13,9 +13,9 @@
  * handler stateless.
  */
 import { mmPost, resolveHttpContext, SkillError } from '../http.js';
+import { getCapabilities } from '../capabilities.js';
 import { emitProgress } from '../progress.js';
 import { isTrue, toNumber } from './shared.js';
-const DEFAULT_VOICE_ID = 'Chinese (Mandarin)_Male_Announcer';
 /**
  * Fallback voice catalog printed when `--list-voices --local` is passed.
  * Mirrors the language-keyed defaults that gen_script.py uses, kept in sync
@@ -64,17 +64,19 @@ export async function genVoice(input, ctxIn) {
     if (!text || typeof text !== 'string' || !text.trim()) {
         throw new SkillError('❌ Please provide --text to specify the text to synthesize');
     }
-    const voiceId = input.voice_id ?? DEFAULT_VOICE_ID;
+    const apiBaseUrl = input.api_base_url;
+    const voice = (await getCapabilities(apiBaseUrl)).voice;
+    const voiceId = input.voice_id ?? voice.defaultVoiceId;
     const speed = toNumber(input.speed, 'speed') ?? 1.0;
-    if (speed < 0.5 || speed > 2.0) {
-        throw new SkillError('❌ speed must be in the range 0.5~2.0');
+    if (speed < voice.speedMin || speed > voice.speedMax) {
+        throw new SkillError(`❌ speed must be in the range ${voice.speedMin}~${voice.speedMax}`);
     }
     const ctx = await resolveHttpContext(ctxIn.skillName, {
-        apiBaseUrl: input.api_base_url,
+        apiBaseUrl,
         privateToken: input.priv_token,
     });
     emitProgress({ phase: 'gen-voice:request', voiceId, speed });
-    const data = await mmPost(ctx, '/tool/minimaxT2aV2', { text, voiceSetting: { voiceId, speed }, outputFormat: 'url' }, { timeoutMs: 120_000 });
+    const data = await mmPost(ctx, '/tool/tts', { provider: voice.provider, text, voiceSetting: { voiceId, speed }, outputFormat: 'url' }, { timeoutMs: 120_000 });
     const audioUrl = data.audio;
     if (!audioUrl) {
         throw new SkillError(`❌ API response did not contain an audio URL: ${JSON.stringify(data)}`);

package/dist/http.d.ts

@@ -14,8 +14,8 @@
  *
  * Base URL resolution:
  *   1. opts.apiBaseUrl                  — caller override
- *   2. process.env.MM_API_BASE_URL      — process env
- *   3. http://localhost:2999/api        — local dev fallback
+ *   2. process.env.MM_API_BASE_URL      — process env (point at local/staging here)
+ *   3. https://api.remixmate.com/api    — production default (zero-config)
  */
 export declare class SkillError extends Error {
     readonly exitCode: number;

package/dist/http.js

@@ -14,12 +14,12 @@
  *
  * Base URL resolution:
  *   1. opts.apiBaseUrl                  — caller override
- *   2. process.env.MM_API_BASE_URL      — process env
- *   3. http://localhost:2999/api        — local dev fallback
+ *   2. process.env.MM_API_BASE_URL      — process env (point at local/staging here)
+ *   3. https://api.remixmate.com/api    — production default (zero-config)
  */
 import { resolvePrivToken, NOT_AUTHENTICATED_HINT } from './auth/resolve.js';
 import { attemptAutoLogin } from './auth/auto-login.js';
-const DEFAULT_API_BASE_URL = 'http://localhost:2999/api';
+const DEFAULT_API_BASE_URL = 'https://api.remixmate.com/api';
 export class SkillError extends Error {
     exitCode;
     constructor(message, exitCode = 1) {

package/dist/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "version": "0.9.6",
-  "generatedAt": "2026-06-15T14:23:52.383Z",
+  "version": "0.9.8",
+  "generatedAt": "2026-07-20T11:13:57.597Z",
   "skills": [
     {
       "id": "export-jianying",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remixmate/cli",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "AI media generation skills for Claude Code / Codex — 11 skills covering image, video, voice, digital human, web capture, script, template registry, rendering, Jianying export, and video deconstruction.",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,13 @@
     "test:cli": "npm run build && node --test test/*.test.mjs",
     "test:validators": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/test-validators.py",
     "test:template-pipeline": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/test-template-pipeline.py",
+    "test:props-contract": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/test-props-contract.py",
+    "test:render-plan": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/test-render-plan-snapshot.py",
+    "test:render-plan:update": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/test-render-plan-snapshot.py --update",
     "test:contracts": "PYTHONDONTWRITEBYTECODE=1 python3 skills/template-registry/scripts/check_contracts.py",
+    "regress": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/regress.py",
+    "regress:update": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/regress.py --update",
+    "check:render": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/render-template-check.py",
     "clean": "node scripts/clean.mjs"
   },
   "keywords": [