Add streaming text-to-pose preview

index.js

@@ -74,6 +74,27 @@ function ensureStyles() {
             min-width: 0;
             width: 100%;
         }
+        .stable-text-playground {
+            grid-column: 1 / -1;
+            min-width: 0;
+        }
+        .stable-text-playground .stable-reading-area {
+            min-height: 180px;
+            font-size: 16px;
+            line-height: 1.65;
+        }
+        .stable-text-playground-title {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            gap: 12px;
+            margin-bottom: 10px;
+        }
+        .stable-text-playground-title h3 {
+            margin: 0;
+            font-size: 16px;
+            color: #0f172a;
+        }
         .stable-video-frame {
             position: relative;
             width: 100%;
@@ -298,6 +319,168 @@ function ensureStyles() {
             font-size: 12px;
             color: #475569;
         }
+        .stable-reading-area {
+            min-height: 120px;
+            border: 1px solid #cbd5f5;
+            border-radius: 8px;
+            padding: 12px;
+            background: #f8fafc;
+            color: #0f172a;
+            line-height: 1.55;
+            font-size: 14px;
+            user-select: text;
+        }
+        .stable-reading-area:focus {
+            outline: none;
+            border-color: #6366f1;
+            box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.1);
+        }
+
+        .stable-dialogue-area {
+            min-height: 360px;
+            border: 1px solid #d7b98a;
+            border-radius: 10px;
+            padding: 18px;
+            background:
+                linear-gradient(135deg, rgba(255, 255, 255, 0.58), rgba(255, 248, 236, 0.2)),
+                repeating-linear-gradient(90deg, #f5e3c4 0, #f5e3c4 18px, #efd6ad 19px, #efd6ad 36px);
+            color: #2f2417;
+            line-height: 1.62;
+            font-size: 15px;
+            user-select: text;
+            box-shadow: inset 0 1px 0 rgba(255,255,255,0.55);
+        }
+        .stable-dialogue-turn {
+            max-width: 82%;
+            margin: 12px 0;
+            padding: 14px 16px;
+            border-radius: 12px;
+            box-shadow: 0 4px 12px rgba(74, 53, 28, 0.12);
+            white-space: normal;
+        }
+        .stable-dialogue-turn.question {
+            margin-left: auto;
+            background: rgba(255, 255, 255, 0.82);
+            border: 1px solid rgba(185, 139, 73, 0.38);
+        }
+        .stable-dialogue-turn.answer {
+            margin-right: auto;
+            background: rgba(255, 250, 240, 0.9);
+            border: 1px solid rgba(161, 113, 48, 0.42);
+        }
+        .stable-dialogue-speaker {
+            display: inline-block;
+            margin-bottom: 8px;
+            padding: 3px 8px;
+            border-radius: 999px;
+            background: #8b5e2e;
+            color: #fff8ed;
+            font-size: 12px;
+            font-weight: 700;
+        }
+        .stable-dialogue-turn p {
+            margin: 8px 0;
+        }
+        .stable-dialogue-turn ul {
+            margin: 8px 0 8px 20px;
+            padding: 0;
+        }
+        .stable-dialogue-turn li {
+            margin: 4px 0;
+        }
+        .stable-selection-popover {
+            position: fixed;
+            right: 22px;
+            bottom: 22px;
+            z-index: 9999;
+            display: none;
+            width: min(380px, calc(100vw - 44px));
+            border-radius: 12px;
+            background: #0f172a;
+            color: #e2e8f0;
+            box-shadow: 0 18px 40px rgba(15, 23, 42, 0.35);
+            overflow: hidden;
+        }
+        .stable-selection-header {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            gap: 10px;
+            padding: 10px 12px;
+            border-bottom: 1px solid rgba(148, 163, 184, 0.25);
+            font-size: 13px;
+            font-weight: 700;
+        }
+        .stable-selection-header button,
+        .stable-selection-actions button {
+            border: none;
+            border-radius: 8px;
+            padding: 7px 10px;
+            font-size: 12px;
+            font-weight: 700;
+            cursor: pointer;
+            background: #e2e8f0;
+            color: #0f172a;
+        }
+        .stable-selection-body {
+            padding: 12px;
+            display: flex;
+            flex-direction: column;
+            gap: 10px;
+        }
+        .stable-selection-text {
+            max-height: 66px;
+            overflow: auto;
+            color: #cbd5e1;
+            font-size: 12px;
+            line-height: 1.45;
+            border-left: 3px solid #6366f1;
+            padding-left: 8px;
+        }
+        .stable-mini-video-frame {
+            position: relative;
+            width: 100%;
+            aspect-ratio: 1 / 1;
+            background: #020617;
+            border-radius: 8px;
+            overflow: hidden;
+        }
+        .stable-mini-video-frame video,
+        .stable-mini-video-frame canvas {
+            position: absolute;
+            inset: 0;
+            width: 100%;
+            height: 100%;
+            object-fit: contain;
+            background: #020617;
+        }
+        .stable-mini-video-frame canvas {
+            display: none;
+        }
+        .stable-mini-placeholder {
+            position: absolute;
+            inset: 0;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: #94a3b8;
+            font-size: 13px;
+            text-align: center;
+            padding: 16px;
+        }
+        .stable-selection-status {
+            min-height: 18px;
+            color: #cbd5e1;
+            font-size: 12px;
+            overflow-wrap: anywhere;
+        }
+        .stable-selection-actions {
+            display: flex;
+            gap: 8px;
+        }
+        .stable-selection-actions button {
+            flex: 1;
+        }
         @media (max-width: 1200px) {
             .stable-signer-root {
                 grid-template-columns: 1fr;
@@ -444,7 +627,7 @@ export default class StableSignerPlugin extends ControlWavePlugin {
                     <div class="stable-control-header">
                         <div class="stable-control-actions">
                             <button id="stable-prewarm" class="btn secondary">Prewarm</button>
-                            <button id="stable-translate" class="btn secondary">Translate Prompt → Gloss</button>
+                            <button id="stable-translate" class="btn secondary">Text → Available Gloss</button>
                         </div>
                         <span class="stable-status-chip" id="stable-status">Idle</span>
                     </div>
@@ -566,6 +749,49 @@ export default class StableSignerPlugin extends ControlWavePlugin {
                         <pre id="stable-logs">(waiting for task...)</pre>
                     </div>
                 </div>
+                <div class="stable-text-playground stable-signer-panel">
+                    <div class="stable-text-playground-title">
+                        <h3>Selection Translation Playground</h3>
+                        <span class="stable-status-chip">Select text to translate</span>
+                    </div>
+                    <div id="stable-selection-template" class="stable-reading-area stable-dialogue-area" tabindex="0" contenteditable="true">
+                        <div class="stable-dialogue-turn question">
+                            <span class="stable-dialogue-speaker">User</span>
+                            <p>Do native signers have difficulty reading written text?</p>
+                        </div>
+                        <div class="stable-dialogue-turn answer">
+                            <span class="stable-dialogue-speaker">Assistant</span>
+                            <p>Yes. This is a well-studied phenomenon. Deaf people whose first language is a sign language often do face difficulty when reading written language. The reason is not cognitive ability. It is a matter of linguistics and language acquisition. Written language is essentially a visual encoding of spoken language. Hearing children already have years of spoken-language immersion before reading; deaf children whose first language is ASL, CSL, or another sign language often approach English or Chinese as a second language, and one without accessible spoken-language support. Empirical work in the United States, including Gallaudet-related longitudinal research, has often found deaf high-school graduates around a fourth-grade median English reading level. Reports in mainland China similarly show delays in written Chinese, especially with function words, passive constructions, complex clauses, metaphor, idioms, and forms that depend on spoken-language and pragmatic experience. There is large variation: early sign-language exposure and bilingual education, sign language as L1 and written language as L2, generally produce much better reading outcomes. This is a core motivation for SLP and SLT: text-to-sign generation addresses a real accessibility gap in news, public notices, medical instructions, and educational materials.</p>
+                        </div>
+                        <div class="stable-dialogue-turn question">
+                            <span class="stable-dialogue-speaker">User</span>
+                            <p>But why do they not just learn text? Their parents usually know English text. In theory, should they not learn text first rather than sign language?</p>
+                        </div>
+                        <div class="stable-dialogue-turn answer">
+                            <span class="stable-dialogue-speaker">Assistant</span>
+                            <p>That intuition is natural, but it depends on a false premise. Parents knowing text does not mean a child can acquire text from them. Writing is not acquired directly; it is a second-order system built on top of an already acquired natural language. Hearing children do not learn text first. They acquire spoken language from age zero to five, then school teaches them to map that known language onto symbols. Deaf children often lack full access to that underlying natural language. You cannot skip language and teach writing directly. The critical-period literature, including work by Mayberry and Newport, shows that early complete language input is crucial; language deprivation can permanently harm later language, second-language learning, and reading. Sign language is not a competitor to reading. It is the foundation for reading. Parents also cannot provide rich language immersion through print: writing apple and pointing to an apple is sparse, slow, and abstract compared with real-time language in daily life. History already tried suppressing sign language through oralism, especially after the 1880 Milan Conference, and the results were disastrous. The correct causal chain is this: deaf children do not read poorly because they learned sign language. Deaf children with early access to a full sign language often learn written language better; those deprived of sign language and forced to rely on incomplete speech or print usually have the worst text outcomes. For SLP and SLT, automatic text-to-sign generation is not a lazy compromise. It provides information through an accessible natural-language modality.</p>
+                        </div>
+                    </div>
+                    <div id="stable-selection-popover" class="stable-selection-popover">
+                        <div class="stable-selection-header">
+                            <span>Sign Translation</span>
+                            <button id="stable-selection-close" type="button">Close</button>
+                        </div>
+                        <div class="stable-selection-body">
+                            <div id="stable-selection-text" class="stable-selection-text"></div>
+                            <div class="stable-mini-video-frame">
+                                <video id="stable-selection-video" controls playsinline loop muted></video>
+                                    <canvas id="stable-selection-canvas" width="512" height="512"></canvas>
+                                <div id="stable-selection-placeholder" class="stable-mini-placeholder">Select English text to generate a sign pose video.</div>
+                            </div>
+                            <div id="stable-selection-status" class="stable-selection-status">Waiting for selection...</div>
+                            <div class="stable-selection-actions">
+                                <button id="stable-selection-translate" type="button">Regenerate</button>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="stable-hint">This is the browser-plugin style test area: select any text, then the floating skeleton signer appears at the bottom-right.</div>
+                </div>
             </div>
         `;
     }
@@ -594,6 +820,23 @@ export default class StableSignerPlugin extends ControlWavePlugin {
         this.refineLogsPre = container.querySelector('#stable-refine-logs');
         this.prewarmBtn = container.querySelector('#stable-prewarm');
         this.translateBtn = container.querySelector('#stable-translate');
+        this.selectionTemplate = container.querySelector('#stable-selection-template');
+        this.selectionPopover = container.querySelector('#stable-selection-popover');
+        this.selectionTranslateBtn = container.querySelector('#stable-selection-translate');
+        this.selectionCloseBtn = container.querySelector('#stable-selection-close');
+        this.selectionTextEl = container.querySelector('#stable-selection-text');
+        this.selectionVideoEl = container.querySelector('#stable-selection-video');
+        this.selectionCanvas = container.querySelector('#stable-selection-canvas');
+        this.selectionCanvasCtx = this.selectionCanvas ? this.selectionCanvas.getContext('2d') : null;
+        this.selectionHasFrame = false;
+        this.selectionPlaceholder = container.querySelector('#stable-selection-placeholder');
+        this.selectionStatus = container.querySelector('#stable-selection-status');
+        this.selectedTemplateText = '';
+        this.selectionGenerationTimer = null;
+        this.selectionGenerationInFlight = false;
+        this.selectionStreamPollingTimer = null;
+        this.selectionStreamCursor = 0;
+        this.lastGeneratedSelection = '';
         this.generateBtn = container.querySelector('#stable-generate');
         this.statusChip = container.querySelector('#stable-status');
         this.promptTextInput = container.querySelector('#stable-prompt-text');
@@ -634,6 +877,16 @@ export default class StableSignerPlugin extends ControlWavePlugin {
         this.stage2RefreshBtn.addEventListener('click', () => this.refreshStage2Videos());
         this.stage1Select.addEventListener('change', () => this.handleStage1Selection());
         this.stage2Select.addEventListener('change', () => this.handleStage2Selection());
+        if (this.selectionTemplate) {
+            this.selectionTemplate.addEventListener('mouseup', () => this.handleTemplateSelection());
+            this.selectionTemplate.addEventListener('keyup', () => this.handleTemplateSelection());
+        }
+        if (this.selectionTranslateBtn) {
+            this.selectionTranslateBtn.addEventListener('click', () => this.handleSelectedTextGenerate(true));
+        }
+        if (this.selectionCloseBtn) {
+            this.selectionCloseBtn.addEventListener('click', () => this.hideSelectionPopover());
+        }
 
         window.addEventListener('websocket-connected', () => {
             this.updateStatus('WebSocket connected');
@@ -671,7 +924,8 @@ export default class StableSignerPlugin extends ControlWavePlugin {
             maxNewTokens: toInt(this.maxNewTokensInput.value, 64),
             refImagePath: this.refImageInput.value,
             normalizePose: this.normalizeCheckbox.checked,
-            hideTorsoLines: this.hideTorsoCheckbox.checked
+            hideTorsoLines: this.hideTorsoCheckbox.checked,
+            translationMode: 'text2gloss'
         };
     }
 
@@ -802,7 +1056,7 @@ export default class StableSignerPlugin extends ControlWavePlugin {
         }
         const payloadPrompt = originalPrompt || promptText;
         const response = await window.controlWaveWebSocket.sendRequest(this.id, {
-            action: 'prompt_to_gloss',
+            action: 'text_to_gloss',
             data: {
                 text: promptText,
                 prompt: payloadPrompt,
@@ -812,9 +1066,173 @@ export default class StableSignerPlugin extends ControlWavePlugin {
         if (!response || response.status !== 'success' || !response.gloss) {
             throw new Error(response?.message || 'Gloss translation failed');
         }
+        if (response.dropped && response.dropped.length > 0) {
+            console.info('[StableSigner] dropped non-renderable text tokens', response.dropped);
+        }
         return response.gloss;
     }
 
+    handleTemplateSelection() {
+        if (!this.selectionTemplate || !this.selectionPopover) return;
+        const selection = window.getSelection();
+        const selectedText = selection ? selection.toString().replace(/\s+/g, ' ').trim() : '';
+        if (!selectedText || selectedText.length < 2) {
+            return;
+        }
+        const range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
+        if (!range || !this.selectionTemplate.contains(range.commonAncestorContainer)) {
+            return;
+        }
+        this.selectedTemplateText = selectedText;
+        if (this.selectionTextEl) {
+            this.selectionTextEl.textContent = selectedText;
+        }
+        if (this.selectionStatus) {
+            this.selectionStatus.textContent = 'Preparing translation...';
+        }
+        if (this.selectionPopover) {
+            this.selectionPopover.style.display = 'block';
+        }
+        if (this.selectionGenerationTimer) {
+            clearTimeout(this.selectionGenerationTimer);
+        }
+        this.selectionGenerationTimer = setTimeout(() => this.handleSelectedTextGenerate(false), 450);
+    }
+
+    hideSelectionPopover() {
+        if (this.selectionGenerationTimer) {
+            clearTimeout(this.selectionGenerationTimer);
+            this.selectionGenerationTimer = null;
+        }
+        if (this.selectionPopover) {
+            this.selectionPopover.style.display = 'none';
+        }
+    }
+
+    async handleSelectedTextGenerate(force = false) {
+        const text = (this.selectedTemplateText || '').trim();
+        if (!text || this.selectionGenerationInFlight) return;
+        if (!force && text === this.lastGeneratedSelection) return;
+        this.selectionGenerationInFlight = true;
+        this.lastGeneratedSelection = text;
+        this.promptTextInput.value = text;
+        this.glossInput.value = '';
+        this.logsPre.textContent = 'Selected text:\n' + text + '\n\nStreaming pose preview...';
+        if (this.selectionStatus) {
+            this.selectionStatus.textContent = 'Preparing pose preview...';
+        }
+        if (this.selectionPlaceholder && !this.selectionHasFrame) {
+            this.selectionPlaceholder.style.display = 'none';
+        }
+        if (this.selectionVideoEl) {
+            this.selectionVideoEl.style.display = 'none';
+            this.selectionVideoEl.removeAttribute('src');
+            this.selectionVideoEl.load();
+        }
+        try {
+            await this.handleGenerateStream();
+        } catch (error) {
+            if (this.selectionStatus) {
+                this.selectionStatus.textContent = (error && error.message) ? error.message : 'Stream failed';
+            }
+            this.selectionGenerationInFlight = false;
+        }
+    }
+
+    async handleGenerateStream() {
+        if (!window.controlWaveWebSocket || !window.controlWaveWebSocket.sendRequest) {
+            throw new Error('WebSocket not ready');
+        }
+        const payload = this.collectPayload();
+        payload.maxNewTokens = Math.min(toInt(this.maxNewTokensInput.value, 64), 18);
+        payload.maxCandidates = Math.min(toInt(this.maxCandidatesInput.value, 10), 3);
+        const response = await window.controlWaveWebSocket.sendRequest(this.id, {
+            action: 'generate_pose_stream',
+            data: payload
+        });
+        if (!response || response.status !== 'running' || !response.job_id) {
+            throw new Error(response?.message || 'Stream generation failed');
+        }
+        if (response.gloss) {
+            this.glossInput.value = response.gloss;
+        }
+        this.selectionStreamCursor = 0;
+        if (this.selectionStreamPollingTimer) {
+            clearTimeout(this.selectionStreamPollingTimer);
+        }
+        this.pollPoseStream(response.job_id);
+    }
+
+    drawStreamFrameToCanvas(dataUrl) {
+        const image = new Image();
+        image.onload = () => {
+            if (!this.selectionCanvas || !this.selectionCanvasCtx) return;
+            if (this.selectionCanvas.width !== image.naturalWidth) {
+                this.selectionCanvas.width = image.naturalWidth;
+            }
+            if (this.selectionCanvas.height !== image.naturalHeight) {
+                this.selectionCanvas.height = image.naturalHeight;
+            }
+            this.selectionCanvasCtx.drawImage(image, 0, 0, this.selectionCanvas.width, this.selectionCanvas.height);
+            this.selectionCanvas.style.display = 'block';
+            this.selectionHasFrame = true;
+            if (this.selectionPlaceholder) {
+                this.selectionPlaceholder.style.display = 'none';
+            }
+        };
+        image.src = dataUrl;
+    }
+
+    async pollPoseStream(jobId) {
+        try {
+            const response = await window.controlWaveWebSocket.sendRequest(this.id, {
+                action: 'get_pose_stream_status',
+                data: {
+                    jobId,
+                    cursor: this.selectionStreamCursor
+                }
+            });
+            if (!response || response.status === 'error') {
+                throw new Error(response?.message || 'Stream polling failed');
+            }
+            const frames = response.frames || [];
+            if (frames.length > 0) {
+                const latest = frames[frames.length - 1];
+                if (this.selectionCanvas && this.selectionCanvasCtx && latest.image) {
+                    this.drawStreamFrameToCanvas(latest.image);
+                }
+                if (this.selectionPlaceholder) {
+                    this.selectionPlaceholder.style.display = 'none';
+                }
+                this.selectionStreamCursor = response.cursor || (this.selectionStreamCursor + frames.length);
+            }
+            if (this.selectionStatus) {
+                const total = response.total_frames ? ` / ${response.total_frames}` : '';
+                this.selectionStatus.textContent = `Gloss: ${(response.gloss || this.glossInput.value || '').trim()} · ${response.frame_count || this.selectionStreamCursor}${total} frames`;
+            }
+            if (response.status === 'running') {
+                this.selectionStreamPollingTimer = setTimeout(() => this.pollPoseStream(jobId), 180);
+                return;
+            }
+            this.selectionGenerationInFlight = false;
+            if (response.logs) {
+                this.logsPre.textContent = response.logs;
+            }
+            if (response.video_url) {
+                await this.updateVideo(response.video_url, response.video_path);
+                await this.refreshRecentVideos();
+            }
+            if (this.selectionStatus && response.status === 'success') {
+                this.selectionStatus.textContent = `Gloss: ${(response.gloss || this.glossInput.value || '').trim()} · completed`;
+            }
+        } catch (error) {
+            // Keep the last displayed frame. Short polling gaps should not be visible to users.
+            if (this.selectionGenerationInFlight) {
+                this.selectionStreamPollingTimer = setTimeout(() => this.pollPoseStream(jobId), 500);
+            }
+        }
+    }
+
     async updateVideo(url, path) {
         if (!url || !this.videoEl) return;
         const absoluteUrl = url.startsWith('http') ? url : `${window.location.origin}${url}`;
@@ -880,6 +1298,20 @@ export default class StableSignerPlugin extends ControlWavePlugin {
 
             this.videoEl.src = objectUrl;
             this.videoEl.load();
+
+            if (this.selectionVideoEl && this.selectionPopover && this.selectionPopover.style.display !== 'none') {
+                this.selectionVideoEl.pause();
+                this.selectionVideoEl.src = objectUrl;
+                this.selectionVideoEl.style.display = 'block';
+                this.selectionVideoEl.load();
+                if (this.selectionPlaceholder) {
+                    this.selectionPlaceholder.style.display = 'none';
+                }
+                const miniPlayPromise = this.selectionVideoEl.play();
+                if (miniPlayPromise && typeof miniPlayPromise.catch === 'function') {
+                    miniPlayPromise.catch(() => {});
+                }
+            }
         } catch (error) {
             resetVideoEl();
             this.videoPlaceholder.style.display = 'flex';

pipeline01_text2gloss.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""Constrained English text -> available gloss translation for StableSigner.
+
+This is the browser-panel fallback path: it only emits gloss tokens that exist
+in the local pose dictionary, so gloss2pose can render the result immediately.
+It is intentionally conservative and can later be replaced by a trained
+text-to-gloss model with the same public functions.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Sequence, Set, Tuple
+
+
+BASE_DIR = Path(__file__).resolve().parent
+DEFAULT_POSE_DICT = BASE_DIR / "pose_dict" / "WLASL_train.json"
+
+
+STOP_WORDS = {
+    "A",
+    "AN",
+    "THE",
+    "AM",
+    "ARE",
+    "IS",
+    "WAS",
+    "WERE",
+    "BE",
+    "BEEN",
+    "BEING",
+    "DO",
+    "DOES",
+    "DID",
+    "TO",
+    "OF",
+    "FOR",
+    "WITH",
+    "AND",
+    "OR",
+    "BUT",
+    "THAT",
+    "THIS",
+    "THESE",
+    "THOSE",
+    "IT",
+    "ITS",
+    "JUST",
+    "VERY",
+    "REALLY",
+}
+
+
+LEMMA_OVERRIDES = {
+    "ME": "I",
+    "MINE": "MY",
+    "MYSELF": "I",
+    "YOURSELF": "YOU",
+    "YOUR": "YOU",
+    "YOURS": "YOU",
+    "HIS": "HE",
+    "HIM": "HE",
+    "HER": "SHE",
+    "HERS": "SHE",
+    "THEIR": "THEY",
+    "THEM": "THEY",
+    "OUR": "WE",
+    "US": "WE",
+    "WENT": "GO",
+    "GONE": "GO",
+    "GOING": "GO",
+    "CAME": "COME",
+    "COMING": "COME",
+    "MADE": "MAKE",
+    "MAKING": "MAKE",
+    "SAID": "SAY",
+    "SAYING": "SAY",
+    "SAW": "SEE",
+    "SEEN": "SEE",
+    "SEEING": "SEE",
+    "LOOKING": "LOOK",
+    "LIKED": "LIKE",
+    "LIKES": "LIKE",
+    "WANTED": "WANT",
+    "WANTS": "WANT",
+    "NEEDED": "NEED",
+    "NEEDS": "NEED",
+    "HELPED": "HELP",
+    "HELPS": "HELP",
+    "LEARNED": "LEARN",
+    "LEARNING": "LEARN",
+    "SIGNED": "SIGN",
+    "SIGNING": "SIGN",
+    "THANKS": "THANK",
+}
+
+
+PHRASE_MAP = {
+    "GOOD MORNING": ["GOOD", "MORNING"],
+    "GOOD AFTERNOON": ["GOOD", "AFTERNOON"],
+    "GOOD NIGHT": ["GOOD", "NIGHT"],
+    "THANK YOU": ["THANK", "YOU"],
+    "SIGN LANGUAGE": ["SIGN", "LANGUAGE"],
+}
+
+
+@dataclass
+class TextToGlossResult:
+    gloss: str
+    tokens: List[str]
+    matched: List[Tuple[str, str]]
+    dropped: List[str]
+
+
+def load_available_glosses(path: Path | str = DEFAULT_POSE_DICT) -> Set[str]:
+    """Load uppercase gloss vocabulary from WLASL-style pose dictionary JSON."""
+    pose_path = Path(path)
+    with pose_path.open("r", encoding="utf-8") as handle:
+        data = json.load(handle)
+    glosses = set()
+    for item in data:
+        gloss = str(item.get("gloss", "")).strip().upper()
+        if gloss:
+            glosses.add(gloss)
+    return glosses
+
+
+def tokenize_english(text: str) -> List[str]:
+    text = text.replace("'", "")
+    return [token.upper() for token in re.findall(r"[A-Za-z0-9]+", text)]
+
+
+def _simple_lemma(token: str) -> List[str]:
+    candidates = [token]
+    if token in LEMMA_OVERRIDES:
+        candidates.append(LEMMA_OVERRIDES[token])
+    if len(token) > 4 and token.endswith("IES"):
+        candidates.append(token[:-3] + "Y")
+    if len(token) > 4 and token.endswith("ING"):
+        candidates.append(token[:-3])
+        if len(token) > 5:
+            candidates.append(token[:-4])
+    if len(token) > 3 and token.endswith("ED"):
+        candidates.append(token[:-2])
+        candidates.append(token[:-1])
+    if len(token) > 3 and token.endswith("ES"):
+        candidates.append(token[:-2])
+    if len(token) > 2 and token.endswith("S"):
+        candidates.append(token[:-1])
+
+    deduped = []
+    seen = set()
+    for candidate in candidates:
+        if candidate and candidate not in seen:
+            deduped.append(candidate)
+            seen.add(candidate)
+    return deduped
+
+
+def _best_vocab_match(token: str, vocab: Set[str]) -> Optional[str]:
+    for candidate in _simple_lemma(token):
+        if candidate in vocab:
+            return candidate
+    return None
+
+
+def _apply_phrase_map(tokens: Sequence[str], vocab: Set[str]) -> Tuple[List[str], List[Tuple[str, str]]]:
+    output: List[str] = []
+    matched: List[Tuple[str, str]] = []
+    i = 0
+    while i < len(tokens):
+        consumed = False
+        for phrase, gloss_tokens in PHRASE_MAP.items():
+            phrase_tokens = phrase.split()
+            if list(tokens[i : i + len(phrase_tokens)]) != phrase_tokens:
+                continue
+            available = [gloss for gloss in gloss_tokens if gloss in vocab]
+            if available:
+                output.extend(available)
+                matched.append((phrase, " ".join(available)))
+                i += len(phrase_tokens)
+                consumed = True
+                break
+        if not consumed:
+            output.append(tokens[i])
+            i += 1
+    return output, matched
+
+
+def translate_text_to_gloss(
+    text: str,
+    vocab: Optional[Iterable[str]] = None,
+    max_tokens: int = 64,
+) -> TextToGlossResult:
+    """Translate English text into a renderable uppercase gloss sequence."""
+    vocab_set = {item.upper() for item in vocab} if vocab is not None else load_available_glosses()
+    raw_tokens = tokenize_english(text)
+    phrase_tokens, phrase_matches = _apply_phrase_map(raw_tokens, vocab_set)
+
+    gloss_tokens: List[str] = []
+    matched: List[Tuple[str, str]] = list(phrase_matches)
+    dropped: List[str] = []
+
+    for token in phrase_tokens:
+        if len(gloss_tokens) >= max_tokens:
+            break
+        if token in STOP_WORDS:
+            dropped.append(token)
+            continue
+        gloss = _best_vocab_match(token, vocab_set)
+        if gloss:
+            gloss_tokens.append(gloss)
+            if token != gloss:
+                matched.append((token, gloss))
+        else:
+            dropped.append(token)
+
+    return TextToGlossResult(
+        gloss=" ".join(gloss_tokens),
+        tokens=gloss_tokens,
+        matched=matched,
+        dropped=dropped,
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Constrained English text to StableSigner gloss.")
+    parser.add_argument("text", help="English text to translate.")
+    parser.add_argument("--pose-dict", default=str(DEFAULT_POSE_DICT), help="WLASL-style pose dictionary JSON.")
+    parser.add_argument("--max-tokens", type=int, default=64)
+    parser.add_argument("--json", action="store_true", help="Print structured JSON instead of only gloss.")
+    args = parser.parse_args()
+
+    vocab = load_available_glosses(args.pose_dict)
+    result = translate_text_to_gloss(args.text, vocab=vocab, max_tokens=args.max_tokens)
+    if args.json:
+        print(
+            json.dumps(
+                {
+                    "gloss": result.gloss,
+                    "tokens": result.tokens,
+                    "matched": result.matched,
+                    "dropped": result.dropped,
+                },
+                ensure_ascii=True,
+                indent=2,
+            )
+        )
+    else:
+        print(result.gloss)
+
+
+if __name__ == "__main__":
+    main()

pipeline02_gloss2pose.py

@@ -653,6 +653,409 @@ class SignLanguageQA:
 
         return filtered
 
+    def _is_valid_point(self, point):
+        return point is not None and len(point) >= 2 and point[0] > 0 and point[1] > 0
+
+    def _face_points_and_mask(self, faces):
+        if faces is None:
+            return None, None, None
+        if faces.ndim == 3:
+            if faces.shape[0] == 0:
+                return None, None, None
+            points = faces[0]
+            owner = 0
+        else:
+            points = faces
+            owner = None
+        if points is None or len(points) == 0:
+            return None, None, None
+        mask = (points[:, 0] > 0) & (points[:, 1] > 0)
+        if np.count_nonzero(mask) < 4:
+            return None, None, None
+        return points, mask, owner
+
+    def _face_scale(self, points, mask):
+        valid = points[mask, :2]
+        if len(valid) < 4:
+            return None
+        min_xy = np.min(valid, axis=0)
+        max_xy = np.max(valid, axis=0)
+        scale = np.linalg.norm(max_xy - min_xy)
+        return scale if scale > 1e-6 else None
+
+    def _translate_nearest_hand_to_wrist_delta(self, frame_data, original_wrists, wrist_deltas):
+        hands = frame_data.get('hands', None)
+        if hands is None:
+            return
+
+        def choose_delta(root):
+            candidates = []
+            for wrist_name, wrist in original_wrists.items():
+                if self._is_valid_point(wrist):
+                    candidates.append((np.linalg.norm(root[:2] - wrist[:2]), wrist_deltas[wrist_name]))
+            if not candidates:
+                return None
+            return min(candidates, key=lambda item: item[0])[1]
+
+        if hands.ndim == 3:
+            for hand_idx in range(hands.shape[0]):
+                root = hands[hand_idx, 0]
+                if not self._is_valid_point(root):
+                    continue
+                delta = choose_delta(root)
+                if delta is not None:
+                    valid = (hands[hand_idx, :, 0] > 0) & (hands[hand_idx, :, 1] > 0)
+                    hands[hand_idx, valid, :2] += delta
+        elif hands.ndim == 2 and len(hands) > 0:
+            root = hands[0]
+            if self._is_valid_point(root):
+                delta = choose_delta(root)
+                if delta is not None:
+                    valid = (hands[:, 0] > 0) & (hands[:, 1] > 0)
+                    hands[valid, :2] += delta
+
+        hands[..., 0] = np.clip(hands[..., 0], 0.0, 1.0)
+        hands[..., 1] = np.clip(hands[..., 1], 0.0, 1.0)
+        frame_data['hands'] = hands
+
+    def build_signer_template(self, npz_data, start_frame=1, end_frame=None):
+        """Build a fixed signer template from a clip.
+
+        The template stores median body keypoints, first-signer bone lengths, and
+        face center/scale. It is intentionally conservative: torso/head/shoulders
+        remain stable, while arms can later inherit directions from each word.
+        """
+        total_frames = self.get_total_frames(npz_data)
+        if total_frames == 0:
+            return None
+        if end_frame is None:
+            end_frame = total_frames
+        start_frame = max(1, start_frame)
+        end_frame = min(total_frames, end_frame)
+
+        body_samples = []
+        face_centers = []
+        face_scales = []
+        for frame_num in range(start_frame, end_frame + 1):
+            frame_data = self.get_frame_data(npz_data, frame_num)
+            if not frame_data:
+                continue
+            bodies = frame_data.get('bodies', None)
+            if bodies is not None and len(bodies) >= 18:
+                body_samples.append(bodies[:, :2].copy())
+            faces = frame_data.get('faces', None)
+            if faces is not None:
+                points, mask, _owner = self._face_points_and_mask(faces)
+                if points is not None:
+                    face_centers.append(np.mean(points[mask, :2], axis=0))
+                    scale = self._face_scale(points, mask)
+                    if scale is not None:
+                        face_scales.append(scale)
+
+        if not body_samples:
+            return None
+
+        stack = np.stack(body_samples, axis=0)
+        valid = (stack[..., 0] > 0) & (stack[..., 1] > 0)
+        template_body = np.zeros((18, 2), dtype=np.float32)
+        for j in range(18):
+            m = valid[:, j]
+            if np.any(m):
+                template_body[j] = np.median(stack[m, j, :2], axis=0)
+
+        body_bones = [
+            (1, 0), (1, 2), (2, 3), (3, 4),
+            (1, 5), (5, 6), (6, 7),
+            (1, 8), (8, 9), (9, 10),
+            (1, 11), (11, 12), (12, 13),
+            (0, 14), (0, 15), (14, 16), (15, 17),
+        ]
+        lengths = {}
+        for parent, child in body_bones:
+            if self._is_valid_point(template_body[parent]) and self._is_valid_point(template_body[child]):
+                length = float(np.linalg.norm(template_body[child] - template_body[parent]))
+                if 0.002 < length < 0.8:
+                    lengths[(parent, child)] = length
+
+        template = {
+            'body': template_body,
+            'lengths': lengths,
+            'face_center': np.median(face_centers, axis=0).astype(np.float32) if face_centers else None,
+            'face_scale': float(np.median(face_scales)) if face_scales else None,
+        }
+        print("   🧍 First-signer template built")
+        print(f"      Body template joints: {np.count_nonzero((template_body[:, 0] > 0) & (template_body[:, 1] > 0))}/18")
+        if template['face_center'] is not None:
+            print(f"      Face center: ({template['face_center'][0]:.3f}, {template['face_center'][1]:.3f})")
+        return template
+
+    def _retarget_arm_to_template(self, bodies, template_body, lengths, shoulder_idx, elbow_idx, wrist_idx):
+        out = template_body.copy()
+        shoulder = template_body[shoulder_idx]
+        if not self._is_valid_point(shoulder):
+            return out
+
+        def direction(a, b, fallback):
+            if self._is_valid_point(a) and self._is_valid_point(b):
+                v = b[:2] - a[:2]
+                n = np.linalg.norm(v)
+                if n > 1e-6:
+                    return v / n
+            if self._is_valid_point(fallback[0]) and self._is_valid_point(fallback[1]):
+                v = fallback[1] - fallback[0]
+                n = np.linalg.norm(v)
+                if n > 1e-6:
+                    return v / n
+            return np.array([0.0, 1.0], dtype=np.float32)
+
+        upper_dir = direction(bodies[shoulder_idx], bodies[elbow_idx], (template_body[shoulder_idx], template_body[elbow_idx]))
+        lower_dir = direction(bodies[elbow_idx], bodies[wrist_idx], (template_body[elbow_idx], template_body[wrist_idx]))
+        upper_len = lengths.get((shoulder_idx, elbow_idx), np.linalg.norm(template_body[elbow_idx] - template_body[shoulder_idx]))
+        lower_len = lengths.get((elbow_idx, wrist_idx), np.linalg.norm(template_body[wrist_idx] - template_body[elbow_idx]))
+        out[elbow_idx] = shoulder + upper_dir * upper_len
+        out[wrist_idx] = out[elbow_idx] + lower_dir * lower_len
+        return out
+
+    def retarget_pose_data_to_first_signer(self, npz_data, template, start_frame=1, end_frame=None, face_mode='retarget'):
+        """Retarget a clip to the first signer's skeleton while preserving arm/hand motion.
+
+        Torso/head/shoulders/hips use the first signer template. Elbow/wrist use
+        the current clip's arm directions with first-signer bone lengths. Hands
+        are translated by wrist deltas. Face local shape may come from the clip,
+        but its center/scale is aligned to the first signer.
+        """
+        if template is None or template.get('body') is None:
+            return npz_data
+        total_frames = self.get_total_frames(npz_data)
+        if total_frames == 0:
+            return npz_data
+        if end_frame is None:
+            end_frame = total_frames
+        start_frame = max(1, start_frame)
+        end_frame = min(total_frames, end_frame)
+
+        template_body = template['body']
+        lengths = template.get('lengths', {})
+        face_center = template.get('face_center')
+        face_scale = template.get('face_scale')
+
+        print("   🧍 Retargeting clip to first signer template")
+        for frame_num in range(start_frame, end_frame + 1):
+            frame_key = f"frame_{frame_num:08d}"
+            bodies_key = f"{frame_key}_bodies"
+            if bodies_key not in npz_data or npz_data[bodies_key] is None:
+                continue
+            bodies = npz_data[bodies_key].copy()
+            if len(bodies) < 18:
+                continue
+            original_wrists = {
+                'right': bodies[4, :2].copy() if len(bodies) > 4 else None,
+                'left': bodies[7, :2].copy() if len(bodies) > 7 else None,
+            }
+
+            new_body_xy = template_body.copy()
+            right_arm = self._retarget_arm_to_template(bodies, template_body, lengths, 2, 3, 4)
+            left_arm = self._retarget_arm_to_template(bodies, template_body, lengths, 5, 6, 7)
+            new_body_xy[[3, 4]] = right_arm[[3, 4]]
+            new_body_xy[[6, 7]] = left_arm[[6, 7]]
+
+            new_bodies = bodies.copy()
+            valid_template = (new_body_xy[:, 0] > 0) & (new_body_xy[:, 1] > 0)
+            new_bodies[valid_template, :2] = new_body_xy[valid_template]
+            new_bodies[:, 0] = np.clip(new_bodies[:, 0], 0.0, 1.0)
+            new_bodies[:, 1] = np.clip(new_bodies[:, 1], 0.0, 1.0)
+            npz_data[bodies_key] = new_bodies
+
+            wrist_deltas = {
+                'right': new_bodies[4, :2] - original_wrists['right'] if original_wrists['right'] is not None and len(new_bodies) > 4 else np.zeros(2),
+                'left': new_bodies[7, :2] - original_wrists['left'] if original_wrists['left'] is not None and len(new_bodies) > 7 else np.zeros(2),
+            }
+            frame_data = self.get_frame_data(npz_data, frame_num)
+            if frame_data:
+                self._translate_nearest_hand_to_wrist_delta(frame_data, original_wrists, wrist_deltas)
+                hands_key = f"{frame_key}_hands"
+                if hands_key in npz_data and 'hands' in frame_data:
+                    npz_data[hands_key] = frame_data['hands']
+
+            faces_key = f"{frame_key}_faces"
+            if face_mode != 'none' and face_center is not None and faces_key in npz_data and npz_data[faces_key] is not None:
+                faces = npz_data[faces_key].copy()
+                points, mask, owner = self._face_points_and_mask(faces)
+                if points is not None:
+                    current_center = np.mean(points[mask, :2], axis=0)
+                    scaled_points = points.copy()
+                    if face_scale is not None:
+                        current_scale = self._face_scale(points, mask)
+                        if current_scale is not None and current_scale > 1e-6:
+                            scaled_points[mask, :2] = current_center + (points[mask, :2] - current_center) * (face_scale / current_scale)
+                    shifted_center = np.mean(scaled_points[mask, :2], axis=0)
+                    scaled_points[mask, :2] += face_center - shifted_center
+                    if owner is None:
+                        faces = scaled_points
+                    else:
+                        faces[owner] = scaled_points
+                    faces[..., 0] = np.clip(faces[..., 0], 0.0, 1.0)
+                    faces[..., 1] = np.clip(faces[..., 1], 0.0, 1.0)
+                    npz_data[faces_key] = faces
+
+        return npz_data
+
+    def stabilize_pose_data(self, npz_data, start_frame=1, end_frame=None, body_smoothing_alpha=0.75):
+        """Stabilize a pose clip with fixed body bone lengths and fixed face scale."""
+        total_frames = self.get_total_frames(npz_data)
+        if total_frames == 0:
+            return npz_data
+        if end_frame is None:
+            end_frame = total_frames
+        start_frame = max(1, start_frame)
+        end_frame = min(total_frames, end_frame)
+        if start_frame > end_frame:
+            return npz_data
+
+        body_bones = [
+            (1, 0),
+            (1, 2), (2, 3), (3, 4),
+            (1, 5), (5, 6), (6, 7),
+            (1, 8), (8, 9), (9, 10),
+            (1, 11), (11, 12), (12, 13),
+            (0, 14), (0, 15), (14, 16), (15, 17),
+        ]
+
+        bone_lengths = {bone: [] for bone in body_bones}
+        face_scales = []
+
+        for frame_num in range(start_frame, end_frame + 1):
+            frame_data = self.get_frame_data(npz_data, frame_num)
+            if not frame_data or 'bodies' not in frame_data:
+                continue
+            bodies = frame_data['bodies']
+            if bodies is not None:
+                for parent, child in body_bones:
+                    if parent < len(bodies) and child < len(bodies):
+                        if self._is_valid_point(bodies[parent]) and self._is_valid_point(bodies[child]):
+                            length = np.linalg.norm(bodies[child, :2] - bodies[parent, :2])
+                            if 0.002 < length < 0.8:
+                                bone_lengths[(parent, child)].append(length)
+
+            faces = frame_data.get('faces', None)
+            if faces is not None:
+                points, mask, _owner = self._face_points_and_mask(faces)
+                if points is not None:
+                    scale = self._face_scale(points, mask)
+                    if scale is not None and 0.002 < scale < 0.8:
+                        face_scales.append(scale)
+
+        median_lengths = {
+            bone: float(np.median(lengths))
+            for bone, lengths in bone_lengths.items()
+            if lengths
+        }
+        median_face_scale = float(np.median(face_scales)) if face_scales else None
+
+        if not median_lengths and median_face_scale is None:
+            print("   ⚠️  Skeleton stabilization skipped: insufficient valid body/face data")
+            return npz_data
+
+        print("   🦴 Skeleton stabilization enabled")
+        if median_lengths:
+            print(f"      Fixed body bones: {len(median_lengths)}")
+        if median_face_scale is not None:
+            print(f"      Fixed face scale: {median_face_scale:.3f}")
+
+        for frame_num in range(start_frame, end_frame + 1):
+            frame_key = f"frame_{frame_num:08d}"
+            bodies_key = f"{frame_key}_bodies"
+            if bodies_key in npz_data and npz_data[bodies_key] is not None:
+                bodies = npz_data[bodies_key].copy()
+                original_wrists = {
+                    'right': bodies[4, :2].copy() if len(bodies) > 4 else None,
+                    'left': bodies[7, :2].copy() if len(bodies) > 7 else None,
+                }
+
+                for parent, child in body_bones:
+                    target_len = median_lengths.get((parent, child))
+                    if target_len is None or parent >= len(bodies) or child >= len(bodies):
+                        continue
+                    if not self._is_valid_point(bodies[parent]) or not self._is_valid_point(bodies[child]):
+                        continue
+                    direction = bodies[child, :2] - bodies[parent, :2]
+                    current_len = np.linalg.norm(direction)
+                    if current_len <= 1e-6:
+                        continue
+                    bodies[child, :2] = bodies[parent, :2] + direction / current_len * target_len
+
+                bodies[:, 0] = np.clip(bodies[:, 0], 0.0, 1.0)
+                bodies[:, 1] = np.clip(bodies[:, 1], 0.0, 1.0)
+                npz_data[bodies_key] = bodies
+
+                wrist_deltas = {
+                    'right': bodies[4, :2] - original_wrists['right'] if original_wrists['right'] is not None and len(bodies) > 4 else np.zeros(2),
+                    'left': bodies[7, :2] - original_wrists['left'] if original_wrists['left'] is not None and len(bodies) > 7 else np.zeros(2),
+                }
+                frame_data = self.get_frame_data(npz_data, frame_num)
+                if frame_data:
+                    self._translate_nearest_hand_to_wrist_delta(frame_data, original_wrists, wrist_deltas)
+                    hands_key = f"{frame_key}_hands"
+                    if hands_key in npz_data and 'hands' in frame_data:
+                        npz_data[hands_key] = frame_data['hands']
+
+            faces_key = f"{frame_key}_faces"
+            if median_face_scale is not None and faces_key in npz_data and npz_data[faces_key] is not None:
+                faces = npz_data[faces_key].copy()
+                points, mask, owner = self._face_points_and_mask(faces)
+                if points is not None:
+                    current_scale = self._face_scale(points, mask)
+                    if current_scale is not None and current_scale > 1e-6:
+                        center = np.mean(points[mask, :2], axis=0)
+                        scaled_points = points.copy()
+                        scaled_points[mask, :2] = center + (points[mask, :2] - center) * (median_face_scale / current_scale)
+                        if owner is None:
+                            faces = scaled_points
+                        else:
+                            faces[owner] = scaled_points
+                        faces[..., 0] = np.clip(faces[..., 0], 0.0, 1.0)
+                        faces[..., 1] = np.clip(faces[..., 1], 0.0, 1.0)
+                        npz_data[faces_key] = faces
+
+        previous_bodies = None
+        for frame_num in range(start_frame, end_frame + 1):
+            frame_key = f"frame_{frame_num:08d}"
+            bodies_key = f"{frame_key}_bodies"
+            if bodies_key not in npz_data or npz_data[bodies_key] is None:
+                continue
+            bodies = npz_data[bodies_key].copy()
+            if previous_bodies is not None and previous_bodies.shape == bodies.shape:
+                original_wrists = {
+                    'right': bodies[4, :2].copy() if len(bodies) > 4 else None,
+                    'left': bodies[7, :2].copy() if len(bodies) > 7 else None,
+                }
+                valid = (
+                    (bodies[:, 0] > 0) & (bodies[:, 1] > 0) &
+                    (previous_bodies[:, 0] > 0) & (previous_bodies[:, 1] > 0)
+                )
+                bodies[valid, :2] = (
+                    body_smoothing_alpha * bodies[valid, :2] +
+                    (1.0 - body_smoothing_alpha) * previous_bodies[valid, :2]
+                )
+                bodies[:, 0] = np.clip(bodies[:, 0], 0.0, 1.0)
+                bodies[:, 1] = np.clip(bodies[:, 1], 0.0, 1.0)
+                npz_data[bodies_key] = bodies
+
+                wrist_deltas = {
+                    'right': bodies[4, :2] - original_wrists['right'] if original_wrists['right'] is not None and len(bodies) > 4 else np.zeros(2),
+                    'left': bodies[7, :2] - original_wrists['left'] if original_wrists['left'] is not None and len(bodies) > 7 else np.zeros(2),
+                }
+                frame_data = self.get_frame_data(npz_data, frame_num)
+                if frame_data:
+                    self._translate_nearest_hand_to_wrist_delta(frame_data, original_wrists, wrist_deltas)
+                    hands_key = f"{frame_key}_hands"
+                    if hands_key in npz_data and 'hands' in frame_data:
+                        npz_data[hands_key] = frame_data['hands']
+
+            previous_bodies = bodies.copy()
+
+        return npz_data
+
     def normalize_pose_data(self, npz_data, reference_point='neck', scale_by='shoulders',
                              target_shoulder_width=0.35, target_shoulder_y=0.45):
         """
@@ -961,7 +1364,10 @@ class SignLanguageQA:
     def generate_video_from_glosses(self, gloss_list, output_path, fps=30, width=480, height=480,
                                     smoothing_frames=5, smoothing_method='none', npz_interpolation_frames=0,
                                     scale_x=1.0, scale_y=1.0, hide_torso_lines=False, ref_image_path=None,
-                                    draw_style='controlnext', normalize_pose=True, draw_conf_threshold=0.6):
+                                    draw_style='controlnext', normalize_pose=True, draw_conf_threshold=0.6,
+                                    stabilize_skeleton=False, npz_interpolation_method='body-anchor',
+                                    retarget_to_first_signer=True, retarget_face_mode='retarget',
+                                    frame_callback=None):
         """Generate video from gloss list with optional progressive scaling and head alignment
 
         Args:
@@ -983,6 +1389,19 @@ class SignLanguageQA:
         all_pose_frames = []
         all_npz_data = []  # Store NPZ data for interpolation
         video_info = []
+        first_signer_template = None
+        streamed_frame_count = 0
+
+        def emit_stream_frame(frame, total_frames=None):
+            nonlocal streamed_frame_count
+            if frame_callback is None or frame is None:
+                return
+            try:
+                frame_callback(streamed_frame_count, frame, total_frames or 0)
+                streamed_frame_count += 1
+            except Exception as cb_err:
+                print(f"⚠️  Frame callback failed at {streamed_frame_count}: {cb_err}")
+
         
         for gloss in gloss_list:
             matched_videos = self.find_gloss_videos(gloss)
@@ -1054,6 +1473,17 @@ class SignLanguageQA:
             if normalize_pose:
                 npz_data = self.normalize_pose_data(npz_data, reference_point='neck', scale_by='shoulders')
 
+            if stabilize_skeleton:
+                npz_data = self.stabilize_pose_data(npz_data, start_frame=start_frame, end_frame=end_frame)
+
+            if retarget_to_first_signer:
+                if first_signer_template is None:
+                    first_signer_template = self.build_signer_template(npz_data, start_frame=start_frame, end_frame=end_frame)
+                npz_data = self.retarget_pose_data_to_first_signer(
+                    npz_data, first_signer_template, start_frame=start_frame, end_frame=end_frame,
+                    face_mode=retarget_face_mode
+                )
+
             # Store NPZ data for potential interpolation
             all_npz_data.append(npz_data)
 
@@ -1077,6 +1507,7 @@ class SignLanguageQA:
                     )
                     if pose_frame is not None:
                         gloss_frames.append(pose_frame)
+                        emit_stream_frame(pose_frame)
 
             if gloss_frames:
                 all_pose_frames.append(gloss_frames)
@@ -1096,7 +1527,7 @@ class SignLanguageQA:
         
         # Apply NPZ interpolation if requested
         if npz_interpolation_frames > 0 and len(all_pose_frames) > 1:
-            print(f"🔄 Applying NPZ interpolation with {npz_interpolation_frames} frames...")
+            print(f"🔄 Applying NPZ interpolation with {npz_interpolation_frames} frames ({npz_interpolation_method})...")
             interpolated_pose_frames = []
             
             for i in range(len(all_pose_frames)):
@@ -1117,7 +1548,7 @@ class SignLanguageQA:
                     interpolated_npz_frames = interpolate_pose_npz(
                         npz1, npz2, 
                         num_frames=npz_interpolation_frames,
-                        method='catmull-rom',
+                        method=npz_interpolation_method,
                         frame1_num=end_frame1,
                         frame2_num=start_frame2
                     )
@@ -1146,6 +1577,7 @@ class SignLanguageQA:
                                 )
                                 if pose_frame is not None:
                                     interpolated_pose_frames.append(pose_frame)
+                                    emit_stream_frame(pose_frame)
                     
                     print(f"   ✅ Added {npz_interpolation_frames} interpolated frames between '{video_info[i]['gloss']}' and '{video_info[i+1]['gloss']}'")
             
@@ -1160,6 +1592,18 @@ class SignLanguageQA:
             for group in all_pose_frames:
                 final_frames.extend(group)
         
+        # Push preview frames before final video encoding, so the browser can play immediately.
+        if frame_callback is not None and streamed_frame_count == 0:
+            print("📡 Streaming preview frames...")
+            total_preview_frames = len(final_frames)
+            for stream_idx, stream_frame in enumerate(final_frames):
+                try:
+                    frame_callback(stream_idx, stream_frame, total_preview_frames)
+                    streamed_frame_count += 1
+                except Exception as cb_err:
+                    print(f"⚠️  Frame callback failed at {stream_idx}: {cb_err}")
+                    break
+
         # Write video using FFmpeg directly for better compatibility
         print("💾 Writing video file...")
         
@@ -1444,7 +1888,7 @@ class SignLanguageQA:
                         smoothing_frames = int(input("Pause frames [default 10]: ").strip() or "10")
                     elif smooth_choice == '5':
                         npz_interpolation_frames = int(input("NPZ interpolation frames [default 10]: ").strip() or "10")
-                        print(f"📊 Using Catmull-Rom spline interpolation for smooth transitions")
+                        print(f"📊 Using body-anchor NPZ interpolation for smooth transitions")
                 
                 # Generate output filename
                 suffix = f"_{smoothing_method}" if smoothing_method != 'none' else ""
@@ -1506,6 +1950,10 @@ def main():
                         help='Smoothing frames (default: 5)')
     parser.add_argument('--npz-interpolation', type=int, default=0,
                         help='Number of NPZ interpolation frames between glosses (default: 0)')
+    parser.add_argument('--npz-interpolation-method',
+                        choices=['body-anchor', 'catmull-rom', 'linear', 'cubic'],
+                        default='body-anchor',
+                        help='NPZ transition method. body-anchor keeps hand/face local shapes and only retargets them to interpolated wrists/neck. (default: body-anchor)')
     parser.add_argument('--scale-x', type=float, default=1.4,
                         help='Progressive X-axis scaling factor (default: 1.4)')
     parser.add_argument('--scale-y', type=float, default=1.5,
@@ -1522,6 +1970,12 @@ def main():
                         help='Normalize pose data to standard coordinate system. This ensures different videos are in the same coordinate space, reducing inconsistency from different video sources. (default: true)')
     parser.add_argument('--max-candidates', type=int, default=10,
                         help='Maximum number of NPZ candidates evaluated per gloss (default: 10, set 0 for unlimited)')
+    parser.add_argument('--stabilize-skeleton', type=str, choices=['true', 'false'], default='false',
+                        help='Stabilize body bone lengths and face scale before rendering (default: false)')
+    parser.add_argument('--retarget-to-first-signer', type=str, choices=['true', 'false'], default='true',
+                        help='Retarget every gloss clip to the first selected signer skeleton. Only arms/hands change across words. (default: true)')
+    parser.add_argument('--retarget-face-mode', choices=['retarget', 'none'], default='retarget',
+                        help='Face handling when retargeting: retarget keeps local face shape but aligns center/scale to first signer; none leaves face unchanged. (default: retarget)')
 
     args = parser.parse_args()
 
@@ -1562,12 +2016,23 @@ def main():
         else:
             print(f"⚠️  Pose normalization disabled")
 
+        if args.stabilize_skeleton == 'true':
+            print(f"🦴 Skeleton stabilization enabled")
+
+        if args.npz_interpolation > 0:
+            print(f"🔄 NPZ interpolation method: {args.npz_interpolation_method}")
+
+        if args.retarget_to_first_signer == 'true':
+            print(f"🧍 Retargeting all glosses to first signer skeleton (face={args.retarget_face_mode})")
+
         success = qa_system.generate_video_from_glosses(
             gloss_list, output_file, args.fps, args.width, args.height,
             args.smoothing_frames, args.smoothing, args.npz_interpolation,
             args.scale_x, args.scale_y, args.hide_torso_lines == 'true',
             args.ref_image_path, args.draw_style, args.normalize_pose == 'true',
-            args.draw_threshold
+            args.draw_threshold, args.stabilize_skeleton == 'true',
+            args.npz_interpolation_method,
+            args.retarget_to_first_signer == 'true', args.retarget_face_mode
         )
 
         if not success:

templates/selection_translation_template.txt

@@ -0,0 +1,7 @@
+User: Do native signers have difficulty reading written text?
+
+Assistant: Yes. This is a well-studied phenomenon. The reason is not cognitive ability, but linguistics and acquisition history. Written language encodes spoken language; many deaf readers approach English or Chinese as a second language without accessible spoken-language support.
+
+User: But why do they not just learn text first if their parents know English text?
+
+Assistant: Writing is not acquired directly. It is built on top of an already acquired natural language. Sign language is not a competitor to reading; it is often the foundation for reading.

utils/npz_interpolation.py

@@ -81,6 +81,141 @@ def catmull_rom_spline(p0, p1, p2, p3, num_points, tension=0.5):
     return np.array(points)
 
 
+
+BODY_TREE = [
+    (1, 2), (2, 3), (3, 4),
+    (1, 5), (5, 6), (6, 7),
+    (1, 8), (8, 9), (9, 10),
+    (1, 11), (11, 12), (12, 13),
+    (1, 0), (0, 14), (14, 16), (0, 15), (15, 17),
+]
+
+
+def _valid_xy(points):
+    return points is not None and points.shape[-1] >= 2
+
+
+def _point_valid(point):
+    return point is not None and len(point) >= 2 and point[0] > 0 and point[1] > 0
+
+
+def _canonicalize_body(body, body_a, body_b, blend=0.9):
+    if body is None or body.shape[0] < 18:
+        return body
+    rec = body.copy()
+    rec[1, :2] = body[1, :2]
+    for parent, child in BODY_TREE:
+        if parent >= len(body) or child >= len(body):
+            continue
+        if not (_point_valid(body[parent]) and _point_valid(body[child])):
+            continue
+        lengths = []
+        for ref in (body_a, body_b):
+            if ref is not None and parent < len(ref) and child < len(ref):
+                if _point_valid(ref[parent]) and _point_valid(ref[child]):
+                    length = np.linalg.norm(ref[child, :2] - ref[parent, :2])
+                    if 0.002 < length < 0.8:
+                        lengths.append(length)
+        if not lengths:
+            continue
+        target_len = float(np.median(lengths))
+        direction = body[child, :2] - body[parent, :2]
+        current_len = np.linalg.norm(direction)
+        if current_len <= 1e-6:
+            continue
+        rec[child, :2] = rec[parent, :2] + direction / current_len * target_len
+    out = body.copy()
+    out[:, :2] = body[:, :2] * (1.0 - blend) + rec[:, :2] * blend
+    out[:, 0] = np.clip(out[:, 0], 0.0, 1.0)
+    out[:, 1] = np.clip(out[:, 1], 0.0, 1.0)
+    return out
+
+
+def _attach_hands_to_body(hands_a, hands_b, body_a, body_b, body_t, alpha):
+    if hands_a is None and hands_b is None:
+        return None
+    if hands_a is None:
+        hands_a = hands_b
+        body_a = body_b
+    if hands_b is None:
+        hands_b = hands_a
+        body_b = body_a
+    if hands_a is None or hands_b is None or hands_a.shape != hands_b.shape:
+        return hands_a if alpha < 0.5 else hands_b
+
+    out_a = np.array(hands_a, copy=True)
+    out_b = np.array(hands_b, copy=True)
+    wrist_ids = [4, 7]
+
+    def attach(src_hands, src_body):
+        attached = np.array(src_hands, copy=True)
+        if src_body is None or body_t is None or len(src_body) <= 7 or len(body_t) <= 7:
+            return attached
+        if src_hands.ndim == 3:
+            for hand_idx in range(src_hands.shape[0]):
+                root = src_hands[hand_idx, 0]
+                if not _point_valid(root):
+                    continue
+                choices = []
+                for wid in wrist_ids:
+                    if _point_valid(src_body[wid]) and _point_valid(body_t[wid]):
+                        choices.append((np.linalg.norm(root[:2] - src_body[wid, :2]), wid))
+                if not choices:
+                    continue
+                wid = min(choices, key=lambda item: item[0])[1]
+                delta = body_t[wid, :2] - src_body[wid, :2]
+                valid = (attached[hand_idx, :, 0] > 0) & (attached[hand_idx, :, 1] > 0)
+                attached[hand_idx, valid, :2] += delta
+        elif src_hands.ndim == 2 and len(src_hands) > 0:
+            root = src_hands[0]
+            choices = []
+            for wid in wrist_ids:
+                if _point_valid(root) and _point_valid(src_body[wid]) and _point_valid(body_t[wid]):
+                    choices.append((np.linalg.norm(root[:2] - src_body[wid, :2]), wid))
+            if choices:
+                wid = min(choices, key=lambda item: item[0])[1]
+                delta = body_t[wid, :2] - src_body[wid, :2]
+                valid = (attached[:, 0] > 0) & (attached[:, 1] > 0)
+                attached[valid, :2] += delta
+        attached[..., 0] = np.clip(attached[..., 0], 0.0, 1.0)
+        attached[..., 1] = np.clip(attached[..., 1], 0.0, 1.0)
+        return attached
+
+    a = attach(out_a, body_a)
+    b = attach(out_b, body_b)
+    out = a * (1.0 - alpha) + b * alpha
+    return out
+
+
+def _attach_faces_to_body(face_a, face_b, body_a, body_b, body_t, alpha):
+    if face_a is None and face_b is None:
+        return None
+    if face_a is None:
+        face_a = face_b
+        body_a = body_b
+    if face_b is None:
+        face_b = face_a
+        body_b = body_a
+    if face_a is None or face_b is None or face_a.shape != face_b.shape:
+        return face_a if alpha < 0.5 else face_b
+
+    def attach(src_face, src_body):
+        attached = np.array(src_face, copy=True)
+        if src_body is None or body_t is None or len(src_body) <= 1 or len(body_t) <= 1:
+            return attached
+        if not (_point_valid(src_body[1]) and _point_valid(body_t[1])):
+            return attached
+        delta = body_t[1, :2] - src_body[1, :2]
+        valid = (attached[..., 0] > 0) & (attached[..., 1] > 0)
+        attached[..., :2][valid] += delta
+        attached[..., 0] = np.clip(attached[..., 0], 0.0, 1.0)
+        attached[..., 1] = np.clip(attached[..., 1], 0.0, 1.0)
+        return attached
+
+    a = attach(face_a, body_a)
+    b = attach(face_b, body_b)
+    return a * (1.0 - alpha) + b * alpha
+
 def interpolate_pose_npz(npz1_data, npz2_data, num_frames=10, method='catmull-rom', frame1_num=None, frame2_num=None):
     """
     Interpolate between two pose NPZ data structures
@@ -200,7 +335,35 @@ def interpolate_pose_npz(npz1_data, npz2_data, num_frames=10, method='catmull-ro
                 data1 = npz1_data[key1]
                 data2 = npz2_data[key2]
                 
-                if method == 'linear':
+                if method == 'body-anchor':
+                    t_eased = ease_in_out_sine(t)
+                    if component == 'bodies':
+                        prev_key = f"{prev_frame_key1}_{component}"
+                        next_key = f"{next_frame_key2}_{component}"
+                        p0 = npz1_data.get(prev_key, data1)
+                        p1 = data1
+                        p2 = data2
+                        p3 = npz2_data.get(next_key, data2)
+                        interpolated = catmull_rom_spline(p0, p1, p2, p3, num_frames)[i]
+                        interpolated = _canonicalize_body(interpolated, data1, data2, blend=0.9)
+                    elif component == 'hands':
+                        body1 = npz1_data.get(f"frame_{frame_num1}_bodies")
+                        body2 = npz2_data.get(f"frame_{frame_num2}_bodies")
+                        body_key = f"frame_{i+1:08d}_bodies"
+                        body_t = interpolated_data.get(body_key)
+                        interpolated = _attach_hands_to_body(data1, data2, body1, body2, body_t, t_eased)
+                    elif component == 'faces':
+                        body1 = npz1_data.get(f"frame_{frame_num1}_bodies")
+                        body2 = npz2_data.get(f"frame_{frame_num2}_bodies")
+                        body_key = f"frame_{i+1:08d}_bodies"
+                        body_t = interpolated_data.get(body_key)
+                        interpolated = _attach_faces_to_body(data1, data2, body1, body2, body_t, t_eased)
+                    elif component.endswith('_scores'):
+                        interpolated = data1 * (1 - t_eased) + data2 * t_eased
+                    else:
+                        interpolated = data1 * (1 - t_eased) + data2 * t_eased
+
+                elif method == 'linear':
                     # Simple linear interpolation with easing
                     t_eased = ease_in_out_cubic(t)
                     interpolated = data1 * (1 - t_eased) + data2 * t_eased

viser_backend.py

@@ -6,6 +6,7 @@ Handles prompt/text -> gloss -> pose video generation for the ControlWorld panel
 
 from __future__ import annotations
 
+import base64
 import contextlib
 import io
 import os
@@ -18,6 +19,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+import cv2
+
 # ControlWorld provides plugin_base in the parent directory of every plugin
 import sys
 
@@ -46,6 +49,7 @@ from plugin_base import PluginBackendBase  # type: ignore  # pylint: disable=wro
 
 # Import local helpers lazily when needed
 from prompt2gloss import build_input as build_prompt_input  # type: ignore
+from pipeline01_text2gloss import load_available_glosses, translate_text_to_gloss  # type: ignore
 
 
 def _to_bool(value: Any, default: bool = False) -> bool:
@@ -96,6 +100,8 @@ class StableSignerBackend(PluginBackendBase):
 
         self._refine_jobs: Dict[str, Dict[str, Any]] = {}
         self._refine_jobs_lock = threading.Lock()
+        self._pose_stream_jobs: Dict[str, Dict[str, Any]] = {}
+        self._pose_stream_jobs_lock = threading.Lock()
 
         self._prompt_tokenizer = None
         self._prompt_model = None
@@ -104,6 +110,7 @@ class StableSignerBackend(PluginBackendBase):
         self._torch = None
         self._qa_instances: Dict[int, SignLanguageQA] = {}
         self._generation_lock = threading.Lock()
+        self._available_glosses = None
 
     # ------------------------------------------------------------------
     # Lazy loaders
@@ -146,6 +153,11 @@ class StableSignerBackend(PluginBackendBase):
             self._qa_instances[key] = SignLanguageQA(max_candidates=key)
         return self._qa_instances[key]
 
+    def _get_available_glosses(self):
+        if self._available_glosses is None:
+            self._available_glosses = load_available_glosses(self.plugin_root / "pose_dict" / "WLASL_train.json")
+        return self._available_glosses
+
     # ------------------------------------------------------------------
     # Helpers
     # ------------------------------------------------------------------
@@ -201,6 +213,19 @@ class StableSignerBackend(PluginBackendBase):
         decoded = tokenizer.batch_decode(outputs, skip_special_tokens=True)[0].strip().upper()
         return decoded
 
+    def _generate_constrained_text_gloss(self, text: str, max_tokens: int) -> Dict[str, Any]:
+        result = translate_text_to_gloss(
+            text,
+            vocab=self._get_available_glosses(),
+            max_tokens=max_tokens,
+        )
+        return {
+            "gloss": result.gloss,
+            "tokens": result.tokens,
+            "matched": result.matched,
+            "dropped": result.dropped,
+        }
+
     def _build_output_path(self, gloss_tokens: List[str], draw_style: str) -> Path:
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         slug = "_".join(gloss_tokens[:4]) if gloss_tokens else "gloss"
@@ -265,6 +290,10 @@ class StableSignerBackend(PluginBackendBase):
 
         if action == "generate_pose":
             return self.handle_generate_pose(data)
+        if action == "generate_pose_stream":
+            return self.handle_generate_pose_stream(data)
+        if action == "get_pose_stream_status":
+            return self.handle_get_pose_stream_status(data)
         if action == "list_recent_videos":
             return {"status": "success", "videos": self._list_recent_videos()}
         if action == "list_sign_videos":
@@ -279,6 +308,8 @@ class StableSignerBackend(PluginBackendBase):
             return self.handle_probe_video(data)
         if action == "prompt_to_gloss":
             return self.handle_prompt_to_gloss(data)
+        if action == "text_to_gloss":
+            return self.handle_text_to_gloss(data)
         if action == "prewarm":
             return self.handle_prewarm(data)
         return super().handle_message(message)
@@ -309,6 +340,23 @@ class StableSignerBackend(PluginBackendBase):
         except Exception as exc:  # pylint: disable=broad-except
             return {"status": "error", "message": str(exc)}
 
+    def handle_text_to_gloss(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        text = (data.get("text") or data.get("prompt") or "").strip()
+        if not text:
+            return {"status": "error", "message": "Text is empty."}
+        max_tokens = _safe_int(data.get("maxNewTokens"), 64)
+        try:
+            result = self._generate_constrained_text_gloss(text, max_tokens)
+            if not result["gloss"]:
+                return {
+                    "status": "error",
+                    "message": "No renderable gloss tokens found in the current pose vocabulary.",
+                    **result,
+                }
+            return {"status": "success", **result}
+        except Exception as exc:  # pylint: disable=broad-except
+            return {"status": "error", "message": str(exc)}
+
     def handle_prewarm(self, data: Dict[str, Any]) -> Dict[str, Any]:
         candidate_counts = data.get("candidateCounts")
         if isinstance(candidate_counts, list):
@@ -353,6 +401,178 @@ class StableSignerBackend(PluginBackendBase):
             "logs": logs or "(no logs)",
         }
 
+    def _encode_stream_frame(self, frame, quality: int = 72) -> Optional[str]:
+        try:
+            frame_bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+            ok, encoded = cv2.imencode(".jpg", frame_bgr, [int(cv2.IMWRITE_JPEG_QUALITY), quality])
+            if not ok:
+                return None
+            return "data:image/jpeg;base64," + base64.b64encode(encoded.tobytes()).decode("ascii")
+        except Exception:
+            return None
+
+    def _create_pose_stream_job(self, gloss: str, output_path: Path) -> Dict[str, Any]:
+        job_id = f"pose_stream_{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}"
+        job = {
+            "id": job_id,
+            "status": "running",
+            "created_at": time.time(),
+            "updated_at": time.time(),
+            "gloss": gloss,
+            "output_path": str(output_path),
+            "video_url": None,
+            "video_path": None,
+            "frames": [],
+            "total_frames": None,
+            "logs": "",
+            "error": None,
+        }
+        with self._pose_stream_jobs_lock:
+            self._pose_stream_jobs[job_id] = job
+        return job
+
+    def _append_pose_stream_frame(self, job_id: str, frame_idx: int, frame, total_frames: int):
+        data_url = self._encode_stream_frame(frame)
+        if not data_url:
+            return
+        with self._pose_stream_jobs_lock:
+            job = self._pose_stream_jobs.get(job_id)
+            if not job:
+                return
+            job["frames"].append({"index": frame_idx, "image": data_url})
+            job["total_frames"] = total_frames
+            job["updated_at"] = time.time()
+
+    def _execute_pose_stream_job(self, job_id: str, qa_system, gloss_tokens: List[str], output_path: Path, settings: Dict[str, Any]):
+        log_buffer = io.StringIO()
+        try:
+            def frame_callback(frame_idx, frame, total_frames):
+                self._append_pose_stream_frame(job_id, frame_idx, frame, total_frames)
+
+            with contextlib.redirect_stdout(log_buffer), contextlib.redirect_stderr(log_buffer):
+                success = qa_system.generate_video_from_glosses(
+                    gloss_tokens,
+                    output_path,
+                    fps=settings["fps"],
+                    width=settings["width"],
+                    height=settings["height"],
+                    smoothing_frames=settings["smoothing_frames"],
+                    smoothing_method=settings["smoothing_method"],
+                    npz_interpolation_frames=settings["npz_interp"],
+                    scale_x=settings["scale_x"],
+                    scale_y=settings["scale_y"],
+                    hide_torso_lines=settings["hide_torso"],
+                    ref_image_path=settings["ref_image"],
+                    draw_style=settings["draw_style"],
+                    normalize_pose=settings["normalize_pose"],
+                    draw_conf_threshold=settings["draw_threshold"],
+                    frame_callback=frame_callback,
+                )
+            logs = self._format_logs(log_buffer)
+            with self._pose_stream_jobs_lock:
+                job = self._pose_stream_jobs.get(job_id)
+                if not job:
+                    return
+                job["logs"] = logs
+                if success and output_path.exists():
+                    job["status"] = "success"
+                    job["video_path"] = str(output_path)
+                    job["video_url"] = self._to_web_url(output_path)
+                else:
+                    job["status"] = "error"
+                    job["error"] = "Video generation failed."
+                job["updated_at"] = time.time()
+        except Exception as exc:  # pylint: disable=broad-except
+            with self._pose_stream_jobs_lock:
+                job = self._pose_stream_jobs.get(job_id)
+                if job:
+                    job["status"] = "error"
+                    job["error"] = str(exc)
+                    job["logs"] = log_buffer.getvalue()
+                    job["updated_at"] = time.time()
+        finally:
+            self._generation_lock.release()
+
+    def handle_generate_pose_stream(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        if not self._generation_lock.acquire(blocking=False):
+            return {"status": "error", "message": "A generation job is already running. Please wait."}
+
+        try:
+            prompt_input_raw = (data.get("prompt") or "").strip()
+            text_input = (data.get("text") or prompt_input_raw).strip()
+            prompt_input = prompt_input_raw or text_input
+            gloss_input = (data.get("gloss") or "").strip()
+            max_new_tokens = _safe_int(data.get("maxNewTokens"), 64)
+            if not gloss_input:
+                if not text_input:
+                    self._generation_lock.release()
+                    return {"status": "error", "message": "Please enter Prompt/Text or a gloss sequence."}
+                translation_mode = (data.get("translationMode") or "text2gloss").strip().lower()
+                if translation_mode == "prompt2gloss":
+                    gloss_input = self._generate_gloss(text_input, prompt_input, max_new_tokens)
+                else:
+                    gloss_input = self._generate_constrained_text_gloss(text_input, max_new_tokens)["gloss"]
+
+            gloss_tokens = [token for token in gloss_input.upper().split() if token]
+            if not gloss_tokens:
+                self._generation_lock.release()
+                return {"status": "error", "message": "Gloss string is empty after normalization."}
+
+            settings = {
+                "fps": _safe_int(data.get("fps"), 30),
+                "width": _safe_int(data.get("width"), 512),
+                "height": _safe_int(data.get("height"), 512),
+                "smoothing_method": data.get("smoothing", "none") or "none",
+                "smoothing_frames": _safe_int(data.get("smoothingFrames"), 0),
+                "npz_interp": _safe_int(data.get("npzInterpolation"), 20),
+                "scale_x": _safe_float(data.get("scaleX"), 1.4),
+                "scale_y": _safe_float(data.get("scaleY"), 1.5),
+                "hide_torso": _to_bool(data.get("hideTorsoLines"), False),
+                "normalize_pose": _to_bool(data.get("normalizePose"), True),
+                "draw_style": (data.get("drawStyle") or "openpose").lower(),
+                "draw_threshold": _safe_float(data.get("drawConfidenceThreshold"), 0.6),
+                "ref_image": (data.get("refImagePath") or "").strip() or None,
+            }
+            max_candidates = _safe_int(data.get("maxCandidates"), 10)
+            qa_system = self._get_qa_system(max_candidates if max_candidates >= 0 else 10)
+            output_path = self._build_output_path(gloss_tokens, settings["draw_style"])
+            job = self._create_pose_stream_job(" ".join(gloss_tokens), output_path)
+            thread = threading.Thread(
+                target=self._execute_pose_stream_job,
+                args=(job["id"], qa_system, gloss_tokens, output_path, settings),
+                name=f"stable-pose-stream-{job['id']}",
+                daemon=True,
+            )
+            thread.start()
+            return {"status": "running", "job_id": job["id"], "gloss": " ".join(gloss_tokens), "fps": settings["fps"]}
+        except Exception as exc:  # pylint: disable=broad-except
+            self._generation_lock.release()
+            return {"status": "error", "message": str(exc)}
+
+    def handle_get_pose_stream_status(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        job_id = (data.get("jobId") or data.get("job_id") or "").strip()
+        cursor = _safe_int(data.get("cursor"), 0)
+        if not job_id:
+            return {"status": "error", "message": "jobId is required."}
+        with self._pose_stream_jobs_lock:
+            job = self._pose_stream_jobs.get(job_id)
+            if not job:
+                return {"status": "error", "message": "Stream job not found."}
+            frames = job["frames"][cursor:]
+            return {
+                "status": job["status"],
+                "job_id": job_id,
+                "gloss": job["gloss"],
+                "frames": frames,
+                "cursor": cursor + len(frames),
+                "frame_count": len(job["frames"]),
+                "total_frames": job.get("total_frames"),
+                "video_url": job.get("video_url"),
+                "video_path": job.get("video_path"),
+                "logs": job.get("logs") if job["status"] != "running" else "",
+                "message": job.get("error"),
+            }
+
     def handle_generate_pose(self, data: Dict[str, Any]) -> Dict[str, Any]:
         if not self._generation_lock.acquire(blocking=False):
             return {"status": "error", "message": "A generation job is already running. Please wait."}
@@ -382,7 +602,12 @@ class StableSignerBackend(PluginBackendBase):
             if not gloss_input:
                 if not text_input:
                     return {"status": "error", "message": "Please enter Prompt/Text or a gloss sequence."}
-                gloss_input = self._generate_gloss(text_input, prompt_input, max_new_tokens)
+                translation_mode = (data.get("translationMode") or "text2gloss").strip().lower()
+                if translation_mode == "prompt2gloss":
+                    gloss_input = self._generate_gloss(text_input, prompt_input, max_new_tokens)
+                else:
+                    gloss_result = self._generate_constrained_text_gloss(text_input, max_new_tokens)
+                    gloss_input = gloss_result["gloss"]
 
             gloss_tokens = [token for token in gloss_input.upper().split() if token]
             if not gloss_tokens: