ככה תערכו סרטונים עם AI החל מחיתוכים ועד אפקטים בתלת מימד (המדריך המלא)

<קלט>
תשאל אותי על שני דברים:
- איזה קובץ לערוך, אם יש בתיקייה יותר מסרטון אחד.
- אם יש משהו שחייב להישאר, למשל שתיקה מכוונת לפני משפט חזק, או חזרה שעשיתי בשביל ההדגשה.
</קלט>

<כיוון>
סרטון שבו הדיבור זורם בלי חורים.
מוחקים כל שתיקה, כל "אה" ו"אמ", כל מילה שנתקעה, וכל משפט שאמרתי פעמיים (נשאר הטייק האחרון והשלם).
משפט שהתחלתי ועזבתי באמצע נמחק כולו.
תיקון עצמי שנשמע טבעי נשאר, וגם חזרה שעשיתי בכוונה.
בכל חיבור נשאר שקט של 0.1 שנייה בסך הכל, חצי אחרי המילה הקודמת וחצי לפני הבאה, כדי ששום עיצור לא ייחתך.
בתחילת הסרטון ובסופו נשאר רק כ-0.05 שנייה של שקט.
</כיוון>

<בנייה>
1. תתמלל עם זמן לכל מילה בעזרת `npx hyperframes transcribe <הקובץ> --language he --model large-v3`.
2. תקרא את התמלול כטקסט רגיל ותחליט מה נחתך לפי המשמעות, משפט אחרי משפט.
3. whisper לרוב לא כותב "אה" ו"אמ", אז תחפש גם רווח בתמלול שבו יש קול ואין מילה.
4. את השתיקות תמדוד מהקול עצמו עם `silencedetect` (סף בסביבות -35dB, מ-0.15 שנייה), כי הזמנים של whisper בקצוות של מילים לא מדויקים.
5. כל נקודת חיתוך יושבת בתוך שקט ומעוגלת לפריים שלם, כדי שהקול לא יזוז מהתמונה אחרי כמה חיבורים.
6. אחרי שאישרתי, תחתוך במעבר אחד של ffmpeg (trim ו-atrim לכל קטע, ואז concat), עם fade של בערך 30 אלפיות שנייה בכל חיבור, כדי שלא יישמע קליק.
7. אפשר להריץ את `transcript-cut` של הסקיל `media-use` עם `--plan` כדי לראות את הקטעים, ואת החיתוך עצמו תעשה במעבר אחד כמו בשלב 6.
8. תשמור על הרזולוציה המקורית כדי שיהיה מקום לזום אחר כך, ובצילום 4K תגיד לי מראש כמה דקות ייקח הקידוד.
9. את זמני המילים בקובץ החתוך תחשב מהתמלול המקורי ולפי מה שנמחק, ותשמור אותם בקובץ json ליד הסרטון.
10. בסוף תמדוד שוב עם `silencedetect` שאין בקובץ החתוך שקט ארוך מ-0.2 שנייה.
11. תציע לי באילו חיבורים זום קטן של בערך 12 אחוז יסתיר את הקפיצה בתמונה.
</בנייה>

<מלכודות>
אל תתמלל מחדש את הקובץ החתוך כדי לקבל זמנים, כי whisper ממציא מילים בנקודות החיבור ומשנה מילים גם במקומות אחרים.
חיתוך שנופל על עיצור בסוף מילה נשמע כמו מילה קטועה, ולכן כל חיתוך נבדק מול עוצמת הקול.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, תתמלל, ותראה לי טבלה של כל החיתוכים: הזמן, המילים שנמחקות והסיבה.
אם אין בצילום שתיקה ארוכה מ-0.2 שנייה ואין טייק כפול, תגיד לי את זה לפני שאתה מקודד.
אל תחתוך לפני שאישרתי.
</התחלה>

<קלט>
תשאל אותי על שלושה דברים:
- איזה סרטון לערוך, אם יש בתיקייה יותר מאחד.
- איזה סגנון כתוביות לבנות, אחד מהשניים:
  - גלולה לבנה עם טקסט שחור, שורה אחת באמצע המסך.
  - כתוביות קינטיות, שבהן כל מילה נכנסת למסך בתנועה ברגע שהיא נאמרת.
- צבע הדגשה למילים החשובות (ברירת המחדל אדום) ופונט עברי (ברירת המחדל Rubik).
</קלט>

<כיוון>
כל מילה שנאמרת מופיעה בכתוביות, בדיוק כמו שנאמרה, כולל פיסוק.
שם של מוצר או תקן (iPhone, USB) נכתב באנגלית, ומילה שעברה לעברית (פרומפט, אינטרנט) נכתבת בעברית.
מספר מדויק נכתב בספרות, ו"אלף" או "אלפי" נשארים במילים, למשל "200 אלף".
בלי מקף בין שתי מילים.
כתובית לא נחתכת בין מילים ששייכות יחד, כמו "כבל רשת" או "מחובר אליו".
אם בחרתי גלולה:
- מלבן לבן עם פינות מעוגלות (רדיוס 20), בגובה של בערך 100 פיקסלים ברוחב 1080, וטקסט שחור במשקל 800, במרכז המסך לרוחב ולגובה.
- בכל כתובית 1 עד 4 מילים (רוב הזמן 3), עד 18 תווים, בין 0.3 ל-1.2 שניות, וכתובית שנמתחת מעבר ל-1.2 בגלל הפסקה מתפצלת לשתיים.
- כתובית נסגרת על פסיק או נקודה שנופלים במילה השנייה עד הרביעית.
- הכתוביות מתחלפות בלי אנימציה, בפריים אחד, בלי חור ובלי חפיפה ביניהן.
- 1 עד 4 מילים בצבע ההדגשה בכל הסרטון: שם של מוצר בפעם הראשונה שהוא נאמר, מספר, או מילה של דחיפות כמו "עכשיו".
אם בחרתי כתוביות קינטיות:
- בכל קבוצה 1 עד 3 מילים, שיורדות שורה אם הן לא נכנסות בשורה אחת, עד 3 שורות, בפס קבוע בחלק התחתון של המרכז.
- כל מילה נכנסת בתחילת המילה המדוברת, בתנועת קפיץ: מתבהרת מטשטוש, וגדלה מעט מעל הגודל הסופי ומתיישבת.
- המילה החזקה בכל משפט במשקל 900 וקצת יותר גדולה, ועד 8 מילים בצבע ההדגשה בכל הסרטון, עם קו תחתון דק שנמתח מימין לשמאל.
- המילה האחרונה בכל קבוצה נשארת על המסך לפחות 0.3 שנייה, ומילה שמתחילה פחות מ-0.3 שנייה אחריה עוברת לאותה קבוצה.
</כיוון>

<בנייה>
1. אם כבר חתכתי את הסרטון עם פרומפט החיתוך, תשתמש בזמני המילים שחושבו שם, ורק אם אין כאלה תתמלל עם `npx hyperframes transcribe <הקובץ> --language he --model large-v3`.
2. תקרא את כל הכתוביות כמשפטים שלמים ותתקן מילים שנשמעות אותו דבר ונכתבות אחרת: א/ע, כ/ח, ט/ת, ק/כ, ב/ו, ס/ז, ס/ש (למשל "מחובר אליו" ולא "עליו", "בזכוכית" ולא "בסכוכית").
3. תתקן גם מילים ש-whisper פיצל או הדביק ("על פיות" שהיא "אלפיות"), ראשי תיבות בלי גרשיים (כמש שהוא קמ"ש), וכתיב של מילים לועזיות, ותשאיר את הניסוח המדובר כמו שהוא.
4. תתקן את הזמנים לפי עוצמת הקול: אחרי שקט whisper מקדים את המילה ב-0.1 עד 0.3 שנייה או מכניס את השקט לתוכה, אז המילה מתחילה ברגע הראשון שבו הקול עולה.
5. את שכבת הכתוביות תבנה בעצמך בקוד, כקומפוזיציה של HyperFrames מעל הסרטון, ולא דרך הסקיל `embedded-captions` שהסקיל `hyperframes` מפנה אליו, כי אין בו עברית ואין בו את שני הסגנונות.
6. אם Rubik לא נמצא בתיקיית הפרויקט, תוריד אותו מ-Google Fonts לתיקייה `assets/fonts` ותטען אותו עם `@font-face`.
7. אם בחרתי בשני הסגנונות, כל סגנון נבנה בתיקיית פרויקט משלו.
8. תמסור את הסרטון עם הכתוביות ובלי הכתוביות, באותה רזולוציה, באותו אורך ועם הקול המקורי (`data-has-audio="true"` בלי `muted`).
</בנייה>

<מלכודות>
כל זמן של כתובית מעוגל לפריים, ואחרי הרינדור תבדוק בפריימים שאין בשום החלפה פריים בלי כתובית, כי הבדיקה האוטומטית של HyperFrames לא תופסת את זה.
את הטשטוש בקינטי תנפיש בנפרד מהקפיץ, ולא תיתן לו לרדת מתחת ל-0, כי הדפדפן פוסל `blur` שלילי והמילה נשארת מטושטשת.
`dir="rtl"` לא נכנס לתגית ה-html, כי אז הרינדור יוצא שחור.
כל מילה ב-span משלה עם `dir="rtl"`, אחרת פסיק או נקודה בסוף המילה עוברים לצד הלא נכון.
בתוך flex הרווח בין שני span נעלם, אז המרווח בין מילים נקבע עם gap.
הפונט נטען עם טקסט עברי, `document.fonts.load('800 100px Rubik', 'אבג')`, אחרת נטען רק החלק הלטיני ורוחבי המילים יוצאים שגויים.
טקסט רק בין x 140 ל-940 מתוך 1080, כי בטלפונים גבוהים אינסטגרם חותך את הצדדים.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, תתמלל, ותראה לי את כל הכתוביות כרשימת משפטים עם זמנים, עם סימון של כל מילה שתיקנת, של המילים להדגשה ושל מילים שאתה לא בטוח בהן, כדי שאבדוק אותן באוזן.
אחרי שאישרתי, תרנדר תצוגה של 10 שניות (תשנה זמנית את `data-duration` ל-10 ותרנדר עם `--quality draft`), ואת כל הסרטון רק אחרי שאישרתי את הסגנון.
</התחלה>

<קלט>
תשאל אותי על שני דברים:
- איזה סרטון, ואם יש בו יותר מאדם אחד או רגעים שבהם הראיתי משהו בצד של הפריים.
- אם יש בסרטון טקסט או גרפיקה שצריכים להישאר בתוך הפריים החדש.
</קלט>

<כיוון>
סרטון של 1080 על 1920 שבו הפנים שלי תמיד בפריים, בלי פסים שחורים למעלה ולמטה.
החיתוך זז רק כשהגוף שלי זז באמת, בתנועה רכה, ותנועות קטנות של הראש לא מזיזות אותו.
העיניים יושבות בערך בשליש העליון של הפריים, עם מרווח קטן מעל הראש.
כל טקסט או גרפיקה שנוסיף אחר כך יושבים בין x 140 ל-940, ולא מעל y 250 או מתחת ל-1570.
</כיוון>

<בנייה>
1. את MediaPipe תתקין בתוך venv עם `pip install mediapipe==0.10.35`, כי הגרסה האחרונה קורסת ב-Mac, ותמצא את הפנים בכל פריים עם `FaceDetector` במצב VIDEO והמודל `blaze_face_short_range.tflite`.
2. לכל פריים תשמור את מרכז הפנים ואת הרוחב שלהן, וכשיש כמה פנים תבחר את אלו עם הציון הכי גבוה, כי ידיים מזוהות לפעמים כפנים בציון נמוך יותר.
3. פריים שבו הפנים לא נמצאו מקבל את הערך של הפריים הקרוב שבו הן כן נמצאו.
4. תחליק את המסלול עם אזור מת של בערך 8 אחוז מרוחב המקור (כ-150 פיקסלים ב-1920), שבתוכו החיתוך לא זז.
5. כשהפנים יוצאות מהאזור המת, החיתוך זז בקפיץ בלי לעבור את היעד עד שהן חוזרות לקצה האזור, ומהר יותר כשהן קרובות לקצה החלון.
6. תחתוך מהגובה המלא של המקור חלון ברוחב גובה כפול 9 חלקי 16, ותגדיל אותו ל-1080 על 1920.
7. תחתוך כל פריים בסקריפט Python ותעביר אותו ישר ל-ffmpeg, ואז תחזיר את הקול המקורי בלי קידוד מחדש.
8. בחיתוך חד במקור (scene מעל 0.3 ב-ffmpeg) החיתוך החדש קופץ למקום החדש באותו פריים.
</בנייה>

<מלכודות>
ממקור של 1920 על 1080 החלון מוגדל כמעט פי 2, אז אם יש לי קובץ 4K תעבוד ממנו, ותגיד לי אם האיכות נפגעת.
אדם נוסף נחשב רק אם הוא מופיע יותר משנייה ברצף בציון מעל 0.8, ואם הוא או משהו חשוב לא נכנסים לפריים, תעצור ותשאל אותי.
החיתוך אף פעם לא יוצא מגבולות המקור, גם כשהפנים קרובות לקצה.
אם העיניים לא יוצאות בשליש העליון תגיד לי, כי חיתוך מהגובה המלא לא יכול להזיז אותן.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, תריץ את זיהוי הפנים, ותראה לי גיליון של 6 פריימים לפני ואחרי מרגעים שונים בסרטון.
אם החיתוך נשאר קבוע כי כמעט לא זזתי, תגיד לי את זה ליד הגיליון.
אחרי שאישרתי, תרנדר ברזולוציה נמוכה את 10 השניות שבהן זזתי הכי הרבה, ואת כל הסרטון רק אחרי האישור השני.
</התחלה>

<קלט>
תשאל אותי על שני דברים:
- איזה סרטון, אם יש כמה בתיקייה.
- צבע המותג שלי, כקוד hex או כתמונה של הלוגו.
</קלט>

<כיוון>
צבעים חיים יותר, עם נטייה ברורה לצבע המותג שלי.
הבהירות לא זזה, לבן ושחור נשארים ניטרליים, והעור טבעי, בלי כתום ובלי ורוד, גם תחת אור צבעוני.
</כיוון>

<בנייה>
1. תוציא 3 פריימים: הפנים הכי גדולות, הכי קטנות, וה-SATAVG הכי גבוה, ואם גודל הפנים כמעט קבוע, מההתחלה ומהסוף במקום שני הראשונים.
2. תעבוד עם `mediapipe.tasks` במצב VIDEO, ב-`mediapipe==0.10.35` שאין בה `mp.solutions`: `FaceDetector` עם `blaze_face_short_range.tflite` מ-`https://storage.googleapis.com/mediapipe-models/face_detector/blaze_face_short_range/float16/latest/blaze_face_short_range.tflite`, ו-`ImageSegmenter` עם `selfie_multiclass_256x256.tflite` מ-`https://storage.googleapis.com/mediapipe-models/image_segmenter/selfie_multiclass_256x256/float32/latest/selfie_multiclass_256x256.tflite`.
3. תמדוד SATAVG עם `signalstats`, ועל העור L* ו-C* ב-Lab, ואת הגוון של העור ושל ריבוע בצבע המותג בזווית ה-UV של signalstats.
4. את המצח תמדוד מעל תיבת הפנים, שמתחילה בגבות, ואת הלחיים בתוכה בין גובה העיניים לאף, ותבדוק בתמונה שהריבועים על עור חשוף, כי הנקודות של `FaceDetector` זזות בכ-20 פיקסלים.
5. תבנה LUT בפורמט cube שעובד באותה זווית UV ולא נוגע בלומה: פיקסלים עד 12 מעלות מגוון העור שבריבועים, ובמעבר חלק עד 30, שומרים על הגוון ומקבלים רבע מהגברת הרוויה, עד פי 1.2, וכל השאר מקבלים את כולה.
פיקסלים כמעט אפורים, עם כרומת UV מתחת ל-0.02 בסקאלה עד 0.5, נשארים כמו שהם, ומעל 0.06 מקבלים את הטיפול המלא, במעבר חלק.
6. גוונים במרחק עד 120 מעלות מהמותג נמשכים אליו בעקומה חלקה, אפס במותג ובקצה ועד 30 מעלות באמצע.
7. LUT שני, עם הטיפול של העור לכל גוון, עובד בתוך מסכת עור מ-`ImageSegmenter`: עור הפנים (מחלקה 3) ועור הגוף (מחלקה 2), מורחבת בכ-6 פיקסלים ועם שוליים מטושטשים.
את המסכות תשמור כסרטון (`-c:v ffv1 -pix_fmt gray`) באותו קצב פריימים, ותכניס אותו לשרשרת כקלט שני עם `format=gray`.
8. בלי `eq`, שמעלה לבד את L* של העור בכ-1.6: השרשרת היא `split` ל-LUT המלא ול-LUT העור, שעובר `alphamerge` עם המסכה ו-`overlay=format=gbrp` מעל המלא, ובמלא רוויה של 1.85 לבינוני, 1.55 לעדין ו-2.2 לחזק.
9. תמדוד על פריים שעבר את השרשרת ישר מהסרטון, לא מ-PNG, ושוב אחרי הרינדור.
10. הבדיקות: SATAVG עולה, L* של העור זז בעד 2, C* שלו עולה בעד 25 אחוז בריבועים ובאחוזון 95 במסכה, YAVG של כל הסרטון זז בפחות מ-3 אחוז, והקיר ליד הראש מתחזק כמו הקיר הרחוק, בלי הילה.
11. תמסור עם הקול המקורי בלי קידוד מחדש.
</בנייה>

<מלכודות>
אם צבע המותג קרוב לגוון העור, תגיד לי שהוא יצבע גם את הפנים, ואם נתתי כמה בלי לבחור, תדחוף לרחוק מהעור ותגיד למה.
עור באור צבעוני מקבל את גוון האור ורק המסכה מגינה עליו, אז תראה לי בתקריב לפני ואחרי את הפנים, הצוואר והידיים.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, ותראה לי פריים אחד בשלוש עוצמות, לפני ואחרי זה לצד זה, עם המספרים.
תגיד לי שבבינוני ובחזק העור זהה, כי ההגברה שלו נעצרת בפי 1.2.
אל תרנדר את כל הסרטון לפני שבחרתי עוצמה.
</התחלה>

<קלט>
תשאל אותי אם בסרטון יש רק דיבור, או גם מוזיקה ואפקטים, ואם הם בקבצים נפרדים, תבקש ממני את הנתיב של כל קובץ.
</קלט>

<כיוון>
הדיבור ברור ובאותה עוצמה מההתחלה ועד הסוף.
העוצמה הכוללת היא -14 LUFS, והשיא האמיתי (true peak) לא עובר את -1.
האפקטים בלי בס, ונשמעים כמו אוויר, תקתוק או נגיעה עדינה ולא כמו חבטה.
המוזיקה, אם יש, נמוכה ב-9 עד 13 dB מהדיבור, ובזמן שמדברים היא יורדת עוד 2 עד 4 dB.
כל אפקט יושב 23 עד 33 dB מתחת לדיבור, בעוצמה הרגעית (400ms) בשיא שלו מול החציון של הדיבור, ואף אחד לא בולט מעליו.
</כיוון>

<בנייה>
1. תמדוד את המקור עם `ffmpeg -i <קובץ> -af loudnorm=I=-14:TP=-1:LRA=11:print_format=json -f null -` ותראה לי את המספרים.
2. על כל אפקט `highpass=f=200`.
3. אם יש מוזיקה, היא יורדת מתחת לדיבור עם `sidechaincompress`, כשהדיבור מפעיל אותה.
4. אחרי המיקס, נרמול בשני מעברים: המעבר השני מקבל את הערכים שנמדדו בראשון (measured_I, measured_TP, measured_LRA, measured_thresh ו-offset) עם `linear=true`.
5. אחרי המעבר השני תבדוק שבשורה normalization_type כתוב linear, ואם כתוב dynamic, תוריד קודם את השיאים עם `alimiter` ב-192kHz, עם גבול שמשאיר את השיא מתחת למינוס 1 גם אחרי ההגברה, תמדוד שוב ותריץ שוב את המעבר השני.
6. תחזיר את הקול לווידאו בלי לקודד את התמונה מחדש.
7. תמדוד שוב את הקובץ הסופי: העוצמה -14 LUFS עם סטייה של עד חצי יחידה, השיא עד -1, ופחות מאחוז אחד מהאנרגיה של האפקטים מתחת ל-200Hz.
</בנייה>

<מלכודות>
נרמול במעבר אחד עובד במצב דינמי ומזיז את העוצמה לאורך הסרטון, ולכן תמיד שני מעברים.
ל-`alimiter` תמיד `level=false`, כי ברירת המחדל מרימה את כל הקול עד 0 dBFS והורסת את המדידה.
loudnorm מוציא קול ב-192kHz, אז תחזיר אותו ל-48kHz עם `-ar 48000`.
כשאבקש "קצת יותר שקט" או "קצת יותר חזק", זה בערך 3dB, שנמדדים בחלונות קצרים מול הגרסה הקודמת.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, תמדוד, ותראה לי לפני ואחרי את העוצמה, השיא והטווח, יחד עם ההגדרות שאתה מתכוון להפעיל.
</התחלה>

<קלט>
תשאל אותי על ארבעה דברים:
- הסרטון או קובץ הקריינות המקורי.
- ההקלטה החדשה, מאותו מיקרופון ובאותו חדר אם אפשר, עם שנייה של שקט לפני המשפט ואחריו.
- איזה משפט מוחלף, כמו שנאמר במקור.
- אם רואים את הפה שלי בזמן המשפט, כי אז השפתיים לא יתאימו למילים החדשות, ואיזה בירול או חיתוך לזווית אחרת יכסה אותו (תציע לי אחד מתוך הסרטון).
</קלט>

<כיוון>
מי שמקשיב לא שומע איפה נכנס המשפט החדש.
אותו צבע של קול, אותה עוצמה, אותו רעש רקע, ובלי קליק או נשימה קטועה בחיבור.
</כיוון>

<בנייה>
1. תתמלל את המקור ואת ההקלטה החדשה עם `npx hyperframes transcribe <קובץ> --language he --model large-v3`, כל קובץ בתיקייה משלו, כי הפקודה דורסת את transcript.json שבתיקייה.
2. תמצא את המשפט השגוי לפי הטקסט, ותחתוך בתוך השקט שלפניו ובתוך השקט שאחריו.
3. את ההקלטה החדשה תגזום ל-50 אלפיות שנייה לפני המילה הראשונה ול-60 אלפיות שנייה אחרי המילה האחרונה.
4. תמדוד את רעש הרקע בשקטים של שני הקבצים, ואם ההקלטה החדשה רועשת יותר תפעיל `afftdn=nr=6`, ואם היא שקטה יותר תוסיף לה רעש רקע מהשקטים של המקור.
5. EQ שמתאים את ההקלטה החדשה למשפט שהיא מחליפה: תמדוד את הספקטרום של שניהם ותפעיל בערך 80 אחוז מההפרש, רק בין 100Hz ל-10kHz ועד 6 dB לכל כיוון.
6. תתאים את העוצמה לדיבור הפעיל ב-10 השניות שלפני החיבור, בלי השקטים.
7. fade של 40 אלפיות שנייה בכל צד של החיבור.
8. אם ההקלטה החדשה ארוכה או קצרה מהמקורית, כל מה שבא אחריה זז באותו הפרש: הכתוביות, האפקטים והבירולים.
9. משפט חדש קצר יותר מקצר את הווידאו שמתחתיו מהסוף שלו, ומשפט ארוך יותר מקבל בירול שמכסה את ההפרש.
10. אם יש אנימציה שמסונכרנת למילים בתוך המשפט, כל מילה חדשה מוצמדת לרגע באנימציה שהיה שייך למילה המקבילה במקור.
11. תמסור את הסרטון המתוקן, ובנוסף את הקריינות המתוקנת כקובץ wav נפרד.
</בנייה>

<מלכודות>
הזמנים של whisper יכולים לזוז עד שנייה, ובמיוחד במילה הראשונה בקובץ (נמדדה גם סטייה של 0.73 שנייה).
לכן תכין תמונה של גרף העוצמה עם קו בכל תחילת מילה, וכל נקודת חיתוך יושבת על השקע הקרוב בגרף, ולא על הזמן של whisper.
EQ מול כל הקריינות במקום מול המשפט המוחלף יוצא פחות מדויק, כי הצלילים במשפטים אחרים שונים.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, ותכין קטע של 10 שניות סביב החיבור כדי שאקשיב לו לפני שאתה מחליף בסרטון המלא.
</התחלה>

ההוראות כאן מחליפות את ראיון הפתיחה של HyperFrames, אז אל תריץ אותו.
<קלט>
תשאל אותי על חמישה דברים:
- הסרטון שבו אמרתי את ההוראות.
- אם הסרטון הסופי לאורך (9:16) או לרוחב (16:9).
- צבעי המותג שלי: צבע רקע כהה, צבע הדגשה אחד, ופונט עברי (ברירת המחדל Rubik).
- כל קובץ שההוראות מזכירות, למשל לוגו, הסרטונים שלי, תמונה של מוצר, או צילום של החדר הריק אם ביקשתי לפרק את הסצנה לשכבות.
- אם יש לי ספרייה של אפקטים קוליים, או שתבחר אותם בעצמך מהקטלוג של HyperFrames.
</קלט>

<כיוון>
תערוך את הסרטון בדיוק לפי ההוראות שאמרתי בו, תשקיע, ותשתמש במושן גרפיקס בסגנון של אקספליינר דוקומנטרי של נטפליקס, בצבעים של המותג שלי.
כל הוראה קורית על המילים שלה, בשנייה שבה אמרתי אותה.
המראה של אקספליינר דוקומנטרי: אובייקטים מצוירים בקווים דקים שזוהרים, זוהר בצבע ההדגשה, תוויות עם נקודה קטנה וקו דק שמוביל לחלק, מצלמה איטית שלא עוצרת, עומק שדה וגרעיניות עדינה.
הטקסט מינימלי, בלי משפטים שחוזרים על מה שאמרתי, ויש על המסך רק טקסט שביקשתי במפורש ותוויות קצרות.
כל התוויות בעברית, מימין לשמאל, בלי מקף בין שתי מילים, וגדולות מספיק כדי לקרוא אותן בטלפון (לפחות 44 פיקסלים, בפריים של 1080 על 1920 או של 1920 על 1080).
כל תנועה בקפיץ, רגועה ויקרה, ומה שנחת נשאר במקום ולא מרחף לנצח, חוץ מדברים שביקשתי שירחפו.
כל איור הגיוני פיזית, ומספר עולה למסך רק אם הוא אמיתי.
מעט אפקטים קוליים, שקטים, בלי בס, ותמיד מתחת לקול שלי.
כתוביות נצרבות רק אם ביקשתי אותן בסרטון, ותמיד תמסור גם גרסה בלי כתוביות.
</כיוון>

<בנייה>
1. תתמלל עם זמן לכל מילה בעזרת `npx hyperframes transcribe <הקובץ> --language he --model large-v3`, ותתקן מילים שגויות לפי ההקשר (`transcript.json` נשמר בתיקייה של הסרטון ולא בתיקייה שבה אתה עובד).
2. תתקן את זמני המילים לפי עוצמת הקול, כי אחרי שקט whisper מקדים את המילה הבאה ב-0.1 עד 0.3 שנייה.
3. תכתוב קובץ BRIEF.md: לכל הוראה המילים המדויקות והזמן שלהן, מה יקרה על המסך, ומתי האפקט נגמר וחוזר למצב רגיל.
4. כל המידע שצריך נבנה פעם אחת לפני הסצנות: מעקב אחרי הידיים והפנים עם MediaPipe אם יש הוראה על הידיים, הגוף שלי בלי הרקע עם `npx hyperframes remove-background`, ופריימים מכל סרטון שביקשתי להראות.
5. את העריכה תבנה כקומפוזיציה של HyperFrames עם three.js, בשכבות מלמטה למעלה: הסרטון, שכבה על הקיר, הגוף שלי בלי הרקע, שכבה קדמית ושכבה לטקסט.
6. כל פריים מחושב רק מהזמן, בלי טיימרים ובלי מספרים אקראיים בזמן הציור.
7. כל הוראה היא סצנה בקובץ משלה עם חלון זמן, ומחוץ לחלון כל מה שהיא הוסיפה מוסתר וכל השכבות המשותפות חוזרות למצב רגיל.
8. אם יש יותר משלוש הוראות, תחלק את העבודה לסוכנים, סוכן לכל סצנה שעובד רק על הקובץ שלו, עם הבריף המשותף.
9. בכל סצנה תוציא פריימים ברגעים של המילים החשובות ותסתכל עליהם, ותעשה לפחות שלושה סבבים של בדיקה ותיקון.
10. סוכן נפרד שלא בנה כלום נותן ציון מתוך 100 לכל סצנה (ביצוע ההוראה על המילים שלה, גימור, תנועה, עברית, התאמה לסגנון, היגיון פיזי) עם תיקונים במספרים, ואתה מתקן עד שהציון עובר 90.
11. את האפקטים הקוליים תמקם מתחת לקול ותגביל את השיא כך שלא יעבור -1 dBTP.
</בנייה>

<מלכודות>
בלי תיקון הזמנים לפי עוצמת הקול, אפקטים מתחילים לפני שאמרתי את המילה.
אובייקט שסצנה הוסיפה נשאר על המסך אחרי החלון שלה, אם לא מסתירים אותו במפורש.
ברגעי המעבר בין סצנות צריך להיות ברור מי שולט במצלמה, בסרטון ובגוף בלי הרקע, אחרת שתי סצנות נלחמות על אותו דבר.
מילה עברית נכנסת שלמה, כי חשיפה מאחורי קו מראה חצי מילה שנראית כמו מקפים.
לוגו של מותג נשאר בצבעים האמיתיים שלו.
את MediaPipe תתקין בתוך venv עם `pip install mediapipe==0.10.35` ותשתמש ב-Tasks API (`HandLandmarker`, `FaceDetector`), כי הגרסה האחרונה ב-pip קורסת ב-Mac בזיהוי הראשון.
סרטון שמוצג בתוך three.js מקבל `texture.needsUpdate = true` בכל פריים ו-`texture.colorSpace = THREE.SRGBColorSpace`, אחרת הוא לא מופיע או יוצא דהוי.
בסיכום של `npx hyperframes render` צריך להיות כתוב `hardware gpu`, ואם כתוב `software gpu` תוסיף לרינדור `--browser-gpu`.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, תתמלל, ותראה לי טבלה של ההוראות: בכל שורה ההוראה כמו שאמרתי אותה, הזמן, מה יקרה על המסך ואיך זה ייגמר.
אל תבנה לפני שאישרתי.
ל-`npx hyperframes render` אין דגל לטווח זמן או להקטנה, ולכן אחרי האישור תעשה עותק זמני וקצר של הקומפוזיציה ב-540 על 960 (או 960 על 540), שמכיל רק 15 שניות, ותרנדר אותו קודם.
את כל הסרטון תרנדר בסוף.
</התחלה>

ההוראות כאן מחליפות את ראיון הפתיחה של HyperFrames, אז אל תריץ אותו.
<קלט>
תשאל אותי על ארבעה דברים:
- הסרטון, ומעל איזו יד הלוגו מרחף: היד שבצד ימין של המסך, זו שבצד שמאל, או שתיהן עם לוגו אחר לכל יד.
- קובץ הלוגו, עדיף SVG, וקובץ לכל לוגו אם יש שניים.
- כמה גדול הלוגו, וברירת המחדל היא בערך הרוחב של כף היד.
- הרגע שבו כל לוגו מופיע והרגע שבו הוא נעלם, לפי מילה שאמרתי או לפי זמן.
</קלט>

<כיוון>
על המילה שבחרתי נדלקת נקודת אור קטנה מעל כף היד, והלוגו צומח ממנה עם סיבוב אחד.
הלוגו בתלת ממד, עם עובי וקצוות מעוגלים, בצבעים האמיתיים שלו.
הוא מרחף מעל כף היד בתנודה איטית של כמה פיקסלים ומסתובב לאט, כדי שרואים שיש לו עומק.
הוא עוקב אחרי היד באיחור קטן של בערך 0.1 שנייה, כמו משהו שמרחף מעליה ולא כמו מדבקה.
אור בצבע הלוגו נופל על כף היד ועל האצבעות, ונחלש כשהלוגו מתרחק מהן.
אם בלוגו כמה צבעים, האור בצבע הדומיננטי שלו.
ביציאה הלוגו מתכווץ חזרה לנקודת אור ונעלם.
</כיוון>

<בנייה>
1. את MediaPipe תתקין בתוך venv עם `pip install mediapipe==0.10.35` ותשתמש ב-Tasks API, כי הגרסה האחרונה ב-pip קורסת ב-Mac בזיהוי הראשון.
2. תריץ את `HandLandmarker` על כל פריים, ותשמור לכל יד את 21 הנקודות שלה בקובץ JSON.
3. פריים שבו היד לא זוהתה מקבל את הערכים של הפריים הקרוב שבו היא כן זוהתה.
4. את נקודת הריחוף תחשב מהנקודות: לרוחב, באמצע בין מרכז כף היד (ממוצע הנקודות 0, 5, 9, 13 ו-17) לאמצע שבין נקודה 2 לנקודה 5, ולגובה, הגובה הנמוך ביותר שבו הלוגו לא נוגע באף אצבע (מרווח של בערך 12 פיקסלים).
5. את המעקב תחליק בתנועת קפיץ שקצת עוברת את היעד ונרגעת, מחושבת מהזמן בלבד.
6. את הלוגו תבנה מה-SVG ב-three.js עם ExtrudeGeometry ושוליים מעוגלים, עם חומר מבריק ושתי מנורות.
7. אם יש רק PNG, תהפוך אותו לצורות וקטוריות לפי השקיפות שלו, צורה נפרדת לכל צבע, ותראה לי אותן לפני הבנייה.
8. את האור על היד תצייר רק בתוך היד, בעזרת הגוף שלי בלי הרקע מ-`npx hyperframes remove-background`.
9. הכל בקומפוזיציה של HyperFrames מעל הסרטון, כשכל פריים מחושב מהזמן.
</בנייה>

<מלכודות>
כשהיד זזה מהר היא מטושטשת והזיהוי נופל, ואז בלי מילוי מהפריים הקרוב הלוגו קופץ לפינה של המסך.
MediaPipe מניח תמונת מראה, ולכן בסרטון רגיל מה שהוא קורא "יד ימין" הוא בדרך כלל היד שבצד שמאל של המסך, והיד נבחרת לפי הצד שלה במסך.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, תריץ את המעקב, ותראה לי גיליון של 6 פריימים עם הנקודות של היד ונקודת הריחוף מסומנות.
אחרי שאישרתי, תראה לי פריים בכניסה, פריים בתנועה מהירה ופריים ביציאה, ורק אז תרנדר 5 שניות סביב הכניסה מעותק זמני וקצר של הקומפוזיציה ב-540 על 960 (או 960 על 540), כי ל-`npx hyperframes render` אין דגל לטווח זמן או להקטנה.
</התחלה>

ההוראות כאן מחליפות את ראיון הפתיחה של HyperFrames, אז אל תריץ אותו.
<קלט>
תשאל אותי על ארבעה דברים:
- איזה סרטון לערוך, אם יש בתיקייה יותר מאחד.
- הטקסט, מילה במילה, והמילה שעליה הוא מתחיל להופיע.
- מתי הטקסט יוצא, על מילה מסוימת או בסוף הקטע.
- צבע ופונט (ברירת המחדל לבן, Rubik במשקל 900).
</קלט>

<כיוון>
הטקסט גדול ויושב על הקיר מאחוריי, והגוף שלי מסתיר רק חלק קטן ממנו, כך שהוא נשאר קריא.
את המקום של הטקסט תבחר לפי איפה שהגוף נמצא לאורך כל הקטע: על הקיר הפנוי בצד של הראש, לא מאחורי הפנים, ונמוך מספיק כדי שהיד תעבור על השורה התחתונה.
כל מילה נכנסת שלמה ברגע שהיא נאמרת: עולה בערך 30 פיקסלים בתנועת קפיץ בלי קפיצה מעבר ליעד, מתבהרת מטשטוש של 8 פיקסלים בתוך 0.3 שנייה, והשקיפות עולה בתוך 0.26 שנייה.
ל-GSAP אין קפיץ כזה מובנה, אז תשתמש בפונקציית ה-ease הזאת: `p => (1-(1+7*p)*Math.exp(-7*p)) / (1-8*Math.exp(-7))`.
לבן עם צל כהה ורך, כדי שיחזיק על הקיר.
החדר נשאר כמו שהוא, בלי להכהות אותו ובלי כתם כהה מאחורי הטקסט.
</כיוון>

<בנייה>
1. תחתוך לקובץ נפרד רק את הקטע שבו הטקסט על המסך, ותפריד בו אותי מהרקע עם `npx hyperframes remove-background <הקטע> -o cutout.webm --quality best`, כי ההפרדה לוקחת עד שנייה וחצי לכל פריים.
2. תנקה את ההילה החלשה סביב הגוף עם `ffmpeg -c:v libvpx-vp9 -i cutout.webm -vf "format=yuva420p,lut=a='st(0\,clip((val-64)/116\,0\,1));255*ld(0)*ld(0)*(3-2*ld(0))'" -c:v libvpx-vp9 -pix_fmt yuva420p -crf 15 -b:v 0 -auto-alt-ref 0 -an cutout-clean.webm`.
3. בלי `-c:v libvpx-vp9` לפני `-i` השקיפות נעלמת בשקט, ולכן אחרי הניקוי תניח את הקובץ מעל צבע מלא ותבדוק פריים עם שיער, אצבעות ואמות.
4. סדר השכבות בקומפוזיציה של HyperFrames, מלמטה למעלה, הוא הקטע המקורי, אחריו הטקסט, ומעל שניהם אני בלי הרקע.
5. שני הסרטונים מתחילים ב-`data-start="0"`, כדי שיהיו מסונכרנים באותו פריים, והשקיפות של שכבת הגוף נקבעת על div שעוטף אותה ולא על הווידאו עצמו.
6. הסרטון המקורי מקבל `data-has-audio="true"` ובלי `muted`, אחרת הקול נעלם.
</בנייה>

<מלכודות>
לא לשים `dir="rtl"` על תגית ה-html, כי הרינדור יוצא שחור, ולכן הכיוון נקבע על אלמנט הטקסט.
הפונט יושב כקובץ בתיקיית assets של הפרויקט ונטען עם `@font-face`, ואם אין לי אותו תוריד אותו מ-Google Fonts.
לפני המדידה תטען אותו עם טקסט עברי, `document.fonts.load('900 100px Rubik', 'אבג')`, אחרת המילים נמדדות בפונט אחר.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, תריץ את ההפרדה, ותראה לי שלושה פריימים: כשהטקסט נכנס, כשיד עוברת מעליו, וכשהוא מלא על המסך.
אל תרנדר את כל הסרטון לפני שאישרתי.
</התחלה>

ההוראות כאן מחליפות את ראיון הפתיחה של HyperFrames, אז אל תריץ אותו.
<קלט>
תשאל אותי על ארבעה דברים:
- הסרטון, והמילים שעליהן הסצנה מתפרקת ומתאחדת.
- צילום של החדר הריק, בלי אף אחד, מאותה מצלמה באותו מקום (מספיקות 3 שניות לפני או אחרי הצילום).
- אם יש על הקיר טקסט או גרפיקה שהוספנו, ואם יש אפקטים שמרחפים לפניי.
- צבע ההדגשה של המותג שלי.
</קלט>

<כיוון>
על המילה שבחרתי, קו אור דק מקיף את הפריים, ואז השכבות נפרדות זו מזו בעומק.
השכבה הכי אחורית היא החדר הריק, לפניה הטקסט או הגרפיקה שעל הקיר, אחריהם אני בלי הרקע, והאפקטים הכי קרובים למצלמה.
אם אין על הקיר טקסט או שאין אפקטים לפניי, השכבה הזאת לא נבנית ואין לה שם.
המצלמה מסתובבת בתנועת קפיץ למבט מהצד ומלמעלה, כך שרואים שהשכבות הן לוחות נפרדים במרחק זה מזה.
כל שכבה מקבלת מסגרת של קו אור דק, ושם קצר בעברית ליד הפינה שלה, עם נקודה וקו דק שמוביל אליה.
השמות נכנסים אחד אחרי השני, מהשכבה האחורית לקדמית.
על מילת האיחוד כל השכבות והמצלמה חוזרות יחד, על אותו קפיץ, ונוחתות בדיוק בתמונה המקורית בלי שום הבדל.
</כיוון>

<בנייה>
1. אם אין צילום של החדר הריק, תראה לי מודל לעריכת תמונה ואת המחיר שלו, ואחרי האישור תיצור איתו את החדר מפריים אחד ותדביק את התוצאה רק באזור של הגוף, שהוא האיחוד של הגוף מכל הפריימים בסצנה ועוד כמה פיקסלים סביבו, כך ששאר החדר נשאר אמיתי.
2. את הגוף שלי בלי הרקע תוציא עם `npx hyperframes remove-background <הסרטון> -o cutout.webm --quality best`, ותבדוק אותו על רקע ירוק לפני הבנייה, כי נשארים בו לפעמים חלקים מהכיסא או מהמסך.
3. את הסצנה תבנה בקומפוזיציה של HyperFrames עם three.js: כל שכבה היא משטח בגודל הפריים, וכשהמצלמה במקום שלה הם מכסים אותו בדיוק.
4. העומק בזמן הפירוק, ביחס לרוחב הפריים: בערך 0.83 מהרוחב אחורה לחדר, 0.42 לקיר, 0 לי ו-0.1 קדימה לאפקטים.
5. כל שכבה נפרדת על קפיץ משלה, עם הפרש קטן ביניהן (עד 0.12 שנייה), והמצלמה מסתובבת לזווית של בערך 40 מעלות לצד ו-9 מעלות מלמעלה ומתרחקת בערך פי 1.4, כדי שכל השכבות והשמות יישארו בתוך הפריים.
6. השמות מצוירים בשכבה שטוחה מעל התלת ממד, במיקום שמחושב מהפינה של כל שכבה, והקווים שמובילים אליהם באורכים שונים לסירוגין, כדי ששני שמות לא יתנגשו.
7. ברגע הפירוק הסרטון המקורי נמצא על המישור שלי ונעלם בהדרגה, ובשליש האחרון של האיחוד הוא חוזר אליו בהדרגה, כדי שהמעבר בין התמונה הרגילה לשכבות לא יקפוץ.
8. תבחר קפיץ שנרגע לפני סוף האיחוד, ובסוף כל ערך נכפה בדיוק למקום שלו, כך שהכפייה מזיזה פחות מפיקסל ואין קפיצה כשהסרטון הרגיל חוזר.
9. כל פריים מחושב רק מהזמן, והכל חוזר למצב רגיל מיד אחרי האיחוד.
</בנייה>

<מלכודות>
סרטון שמוצג בתוך three.js מקבל `texture.needsUpdate = true` בכל פריים ו-`texture.colorSpace = THREE.SRGBColorSpace`, אחרת הוא לא מופיע או יוצא דהוי.
אל תכהה את החדר ואל תוסיף לו צבע, כי זה נראה עכור.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, ותראה לי את צילום החדר הריק ליד פריים מהסרטון.
אחרי שאישרתי, תראה לי ארבעה פריימים (רגע הפירוק, השיא, השמות והנחיתה), ורק אז תרנדר את הקטע מעותק זמני וקצר של הקומפוזיציה ב-540 על 960 (או 960 על 540), כי ל-`npx hyperframes render` אין דגל לטווח זמן או להקטנה.
</התחלה>

ההוראות כאן מחליפות את ראיון הפתיחה של HyperFrames, אז אל תריץ אותו.
<קלט>
תשאל אותי על חמישה דברים:
- הסרטון, אם הוא לאורך (9:16) או לרוחב (16:9), ובאיזה צד של המסך יהיה העיגול שלי.
- צבע רקע כהה, צבע הדגשה ופונט עברי של המותג שלי.
- המוצר, ואם יש לי קובץ תלת ממד שלו (GLB), כי אחרת תבנה אותו מצורות פשוטות לפי המידות האמיתיות.
- על אילו חלקים לשים תוויות, או שתציע 4 עד 6 חלקים מרכזיים ומשפט הסבר קצר לכל אחד.
- המילים שעליהן קורה כל שלב: המסגרת נסגרת, המוצר נכנס, מתפרק, מתרכב, והסרטון שלי חוזר למסך מלא.
</קלט>

<כיוון>
על המילה הראשונה, הקצוות של הפריים נמשכים פנימה על קפיצים רכים, הסרטון הופך לעיגול במרכז, ואז העיגול זז לצד שבחרתי.
סביב העיגול קו אור דק עם זוהר עדין בצבע ההדגשה, וצל רך מתחתיו.
מאחורי העיגול רקע כהה בצבעי המותג שלי, שזז לאט.
בחצי השני המוצר נכנס מלמטה על קפיץ, נעצר, ומרחף לאט עם סיבוב איטי של עד 25 מעלות לכל צד.
על המילה של הפירוק הוא מסתובב לזווית מאחור ומהצד, והחלקים נפרדים לאורך ציר העומק, כל אחד על קפיץ משלו עם הפרש קטן.
החלקים מצוירים בקווים דקים ובהירים עם זוהר, בסגנון של אקספליינר דוקומנטרי.
התוויות נכנסות אחת אחרי השנייה: נקודה על החלק, קו דק שמוביל אליה, שם החלק ושורה אחת של הסבר, בעברית ובגודל של לפחות 44 פיקסלים, בפריים של 1080 על 1920 או של 1920 על 1080.
על המילה של ההרכבה התוויות נאספות, החלקים חוזרים למקום בסדר הפוך ונוחתים בנקישה קטנה, והמוצר מסתובב חזרה אליי שלם.
בסוף המוצר יוצא מהמסך, ורק אחר כך העיגול נפתח חזרה לפריים מלא, דרך מלבן מעוגל, ונוחת בדיוק בתמונה המקורית.
</כיוון>

<בנייה>
1. תחפש את רשימת החלקים האמיתית של המוצר ממקור אמיתי, כמו מדריך פירוק, ותראה לי אותה עם המקור.
2. את המוצר תבנה ב-three.js במידות אמיתיות במילימטרים, ותגדיל אותו כך שימלא את החצי שלו במסך עם שוליים נדיבים (בסרטון לרוחב זה בערך 0.6 מגובה הפריים).
3. אם ב-GLB כל המוצר הוא רשת אחת, אי אפשר לפרק אותו, ואז תבנה את החלקים מצורות פשוטות לפי המידות האמיתיות.
4. את העיגול תחתוך על עטיפה שמסביב ל-`<video>` ולא על ה-`<video>` עצמו, כי ברינדור HyperFrames מחליף אותו בתמונה, והעיגול אף פעם לא יוצא מגבולות הסרטון המקורי, כך שקצה של הפריים לא נראה בשום רגע.
5. את התוויות תצייר בשכבה שטוחה מעל התלת ממד, במיקום שמחושב מהנקודה של כל חלק, והקווים באורכים שונים לסירוגין כדי ששתי תוויות לא יתנגשו.
6. הכל בקומפוזיציה של HyperFrames, כשכל פריים מחושב רק מהזמן.
</בנייה>

<מלכודות>
חלק שלא קיים במוצר האמיתי, או מספר שלא נבדק, לא עולים למסך.
תווית לא עוברת על העיגול ולא על תווית אחרת.
אם הסרטון מוצג בתוך three.js, הוא מקבל `texture.needsUpdate = true` בכל פריים ו-`texture.colorSpace = THREE.SRGBColorSpace`, אחרת הוא לא מופיע או יוצא דהוי.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, ותראה לי את רשימת החלקים ואת הטקסט של התוויות לאישור.
אחרי שאישרתי, תראה לי פריים מכל שלב (עיגול, מוצר שלם, פירוק, תוויות, הרכבה, חזרה), ורק אז תרנדר את הקטע מעותק זמני וקצר של הקומפוזיציה ב-540 על 960 (או 960 על 540), כי ל-`npx hyperframes render` אין דגל לטווח זמן או להקטנה.
</התחלה>

ההוראות כאן מחליפות את ראיון הפתיחה של HyperFrames, אז אל תריץ אותו.
<קלט>
תשאל אותי על שלושה דברים:
- הסרטון, והמילים שעליהן הכרטיסים עולים, מרחפים, מתחילים להסתובב ועפים החוצה.
- 6 עד 8 סרטונים שלי בתיקייה, עם מספר בתחילת השם לפי הסדר מהנצפה ביותר.
- אם להציג מספר צפיות, ואז את המספרים האמיתיים לכל סרטון.
</קלט>

<כיוון>
כל סרטון הוא כרטיס לאורך עם פינות מעוגלות, שמתנגן בלי קול.
על המילה הראשונה הכרטיסים עולים מהקצוות של המסך ונעמדים בקשת מעל הראש ולצדדים, כולם מאחוריי.
על המילה של הריחוף הם מרחפים קצת יותר, בתנועה איטית וקטנה.
על המילה של הסיבוב הקשת יורדת למסלול נטוי סביבי, והמסלול מאיץ: החצי הקרוב עובר מלפניי והחצי הרחוק מאחוריי.
קו אור דק וחלש מצייר את המסלול.
אם ביקשתי, רק שלושת הסרטונים הכי נצפים מקבלים תווית קטנה עם אייקון של עין ומספר הצפיות האמיתי.
ביציאה הכרטיסים עפים החוצה מהמסך.
</כיוון>

<בנייה>
1. תפריד אותי מהרקע עם `npx hyperframes remove-background <הסרטון> -o cutout.webm --quality best`.
2. תמצא את הפנים בכל פריים עם `FaceDetector` של MediaPipe, כדי שמרכז המסלול יזוז איתי והכרטיסים לא יעלו על הפנים, ואת MediaPipe תתקין בתוך venv עם `pip install mediapipe==0.10.35`, כי הגרסה האחרונה ב-pip קורסת ב-Mac.
3. מכל סרטון שלי תוציא פריימים קטנים (רוחב של בערך 360 פיקסלים) ותטען אותם כתמונות, כי שמונה סרטונים שמתנגנים יחד בדפדפן כבדים מדי, ואם יש יותר מכמה מאות פריימים, תאחד את הפריימים של כל סרטון לגיליון אחד בקצב של 15 פריימים לשנייה.
4. את המסלול תבנה ב-three.js בקומפוזיציה של HyperFrames, עם שלוש שכבות: הכרטיסים שמאחוריי, אני בלי הרקע, והכרטיסים שלפניי.
5. כרטיס עובר משכבה לשכבה רק כשהוא בקצה הצדדי של המסלול, רחוק ממני, כי מעבר מול הגוף נראה כמו כרטיס שחותך אותי.
6. כל פריים מחושב רק מהזמן, והכרטיסים נכנסים בקפיצים בלי קפיצה גדולה מעבר ליעד.
</בנייה>

<מלכודות>
מספר צפיות שלא נתתי לך לא עולה למסך.
סרטון שמוצג בתוך three.js, כמו הגוף שלי בלי הרקע, מקבל `texture.needsUpdate = true` בכל פריים ו-`texture.colorSpace = THREE.SRGBColorSpace`, אחרת הוא לא מופיע או יוצא דהוי.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, ותראה לי ארבעה פריימים: הקשת, הריחוף, המסלול כשכרטיס עובר מלפניי, והיציאה.
אחרי שאישרתי, תרנדר את הקטע מעותק זמני וקצר של הקומפוזיציה ב-540 על 960 (או 960 על 540), כי ל-`npx hyperframes render` אין דגל לטווח זמן או להקטנה.
</התחלה>

ההוראות כאן מחליפות את ראיון הפתיחה של HyperFrames, אז אל תריץ אותו.
תתמלל את הסרטון עם זמן לכל מילה, בעזרת `npx hyperframes transcribe <הקובץ> --language he --model large-v3`, ותבחר בכל משפט לכל היותר מילה אחת, הכי חזקה, כדי שהזום יישאר מיוחד.
תראה לי את רשימת המילים עם הזמנים, ותחכה לאישור לפני שאתה בונה.
על כל מילה כזאת יש זום פנימה של 10 עד 15 אחוז, בתנועת קפיץ שמתחילה עם תחילת המילה, מהירה בהתחלה ונעצרת בעדינות בלי לעבור את היעד.
לקפיץ הזה תשתמש ב-ease `p => (1-(1+7*p)*Math.exp(-7*p)) / (1-8*Math.exp(-7))`, כי ב-GSAP אין כזה מובנה.
מרכז הזום הוא הפנים שלי, כך שהן אף פעם לא יוצאות מהפריים, והוא נכתב באחוזים מהפריים ולא בפיקסלים.
את הפנים תמצא עם `FaceDetector` של MediaPipe, שתתקין בתוך venv עם `pip install mediapipe==0.10.35` כי הגרסה האחרונה קורסת ב-Mac.
בכל פריים תבחר את הזיהוי עם הציון הכי גבוה בחצי העליון של הפריים ותחליק את המסלול, כי ידיים מזוהות לפעמים כפנים.
הזום נשאר עד החיתוך הבא וחוזר שם ל-100 אחוז בבת אחת, ואם אין חיתוך עד המשפט הבא, הוא חוזר במילה הראשונה של המשפט הבא.
במשפט ארוך מותרת דחיפה איטית פנימה של 2 עד 4 אחוז, ולא יותר.
הסרטון מקבל `data-has-audio="true"` בלי `muted`, כדי שהקול יישאר.
תעבוד מהקובץ ברזולוציה המקורית, ואם הוא לא גדול מהפלט לפחות ב-15 אחוז, תגיד לי שהזום יטשטש.
קודם תרנדר 10 שניות מעותק זמני של הפרויקט ב-540 על 960 (או 960 על 540), כי ל-`npx hyperframes render` אין דגל לטווח זמן או להקטנה, ואת כל הסרטון רק אחרי שאישרתי.

ההוראות כאן מחליפות את ראיון הפתיחה של HyperFrames, אז אל תריץ אותו.
<קלט>
תשאל אותי על ארבעה דברים:
- המשפט שהאנימציה מלווה, או הסרטון, ואז תתמלל אותו בעצמך.
- צבע המותג שלי ופונט עברי (ברירת המחדל Rubik).
- הגודל, 1080 על 1920 לרילס או 1920 על 1080 ליוטיוב.
- איפה בפריים יושבים הפנים שלי והכתוביות, כדי שהאנימציה לא תעלה עליהם.
</קלט>

<כיוון>
האנימציה מינימלית ככל האפשר, עם מילה או שתיים בעברית, אייקון בקו אחד וצורות פשוטות.
בלי רקע, בלי עיטורים, ובלי משפט שחוזר על מה שנאמר בסרטון.
דברים שמניתי באותה נשימה נכנסים לסצנה אחת שמצטברת, ולא לקליפים נפרדים.
המשטחים כמעט אטומים, 85 עד 90 אחוז, כי שקיפות של 50 עד 70 אחוז נראית דהויה על וידאו אמיתי.
הטקסט והאייקונים עצמם אטומים לגמרי.
כל אלמנט נכנס בתנועת קפיץ ואז נשאר במקום, בלי ריחוף או פעימה שלא נגמרים.
כל הטקסט בעברית, Rubik, עם ריווח אותיות של כמעט אפס.
שוליים נדיבים, ובפורמט לאורך הקצה העליון של האלמנטים לא מעל y 300, כי הממשק של הרשתות מכסה את החלק העליון.
</כיוון>

<בנייה>
1. קומפוזיציה של HyperFrames בלי שום רקע, כשגם ה-html וגם ה-body שקופים.
2. רינדור שקוף עם `npx hyperframes render <התיקייה> --format mov --output clip.mov`, שמוציא ProRes 4444 עם שקיפות.
3. תבדוק עם `ffprobe -show_entries stream=pix_fmt` שהפורמט מתחיל ב-yuva.
4. תוכיח שהשקיפות עובדת: תניח את הקליפ מעל צבע ירוק מלא באותו גודל של הקליפ, עם `ffmpeg -f lavfi -i color=c=0x1E7A46:s=<רוחב>x<גובה>:d=<משך> -i clip.mov -filter_complex "[0][1]overlay=shortest=1" -ss <זמן> -frames:v 1 test.png`, ותסתכל שהרקע נשאר ירוק.
5. בנוסף תוציא MP4 של אותה אנימציה על רקע בצבע המותג, למי שהתוכנה שלו לא קוראת MOV שקוף: `ffmpeg -f lavfi -i color=c=<צבע>:s=<רוחב>x<גובה>:r=30:d=<משך> -i clip.mov -filter_complex "[0][1]overlay=shortest=1,format=yuv420p" -c:v libx264 -crf 16 clip-brand.mp4`.
6. אם האלמנטים עצמם בצבע המותג, הרקע של ה-MP4 יהיה בגוון כהה יותר של המותג, כדי שהצורות לא ייעלמו.
</בנייה>

<מלכודות>
טקסט עם גרדיאנט בתוך האותיות יוצא שקוף לגמרי ברינדור, ולכן משתמשים בצבע מלא עם זוהר מאחורי האותיות.
צל או הכהיה בפינות שיושבים מעל האלמנטים הופכים לבן לאפור, ולכן לבן צריך להימדד בערך 255 בפריים המרונדר.
לא לשים `dir="rtl"` על תגית ה-html, כי הרינדור יוצא שחור.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, ולפני שאתה מרנדר תצלם פריים מכל שלב של האנימציה עם `npx hyperframes snapshot --at <זמנים> --no-end` ותראה לי אותם מונחים מעל צבע מלא.
</התחלה>

<קלט>
תשאל אותי על ארבעה דברים:
- הסרטון שממנו לוקחים את הפנים שלי, או תמונות חדות שלי מקדימה ומהצד.
- הסצנה, כלומר איפה הקליפ מתרחש, מה קורה בו ומה הבגדים שלי.
- האורך (בדרך כלל 5 שניות) והיחס, 9:16 או 16:9.
- אם מי שבסרטון גבר או אישה, כדי שהפרומפטים באנגלית ייכתבו נכון.
</קלט>

<כיוון>
הקליפ נראה כמו צילום טלפון אמיתי עם אור טבעי וצבעים אמיתיים, ואין בו מראה קולנועי.
הפנים שלי נשארות הפנים שלי מהפריים הראשון ועד האחרון.
חיוך רגוע במקום צחוק גדול.
בלי טקסט, בלי כתוביות, בלי מוזיקה ובלי קול בתוך הקליפ.
</כיוון>

<בנייה>
1. תבדוק ש-fal מחובר אליך, ואם לא, תריץ בעצמך `claude mcp add --transport http --scope user fal https://mcp.fal.ai/mcp-relay`, ואז תגיד לי לכתוב `/mcp`, לבחור fal ולהתחבר עם החשבון שלי, ושהתשלום יורד מארנק שטוענים מראש ב-fal. אם fal לא מופיע שם, תגיד לי לסגור ולפתוח את קלוד קוד.
2. תוציא מהסרטון 4 פריימים חדים, אחד מקדימה ושלושה מזוויות קצת שונות (אחד מהם עם חיוך), ותראה לי אותם לאישור.
3. את 4 הפריימים תעלה ל-fal עם `upload_file`, כי המודלים מקבלים רק כתובות.
4. תמצא ב-fal מודל שמייצר וידאו מתמונה ומקבל גם פריים פתיחה וגם פנים אמיתיות כרפרנס, כי חלק מהמודלים חוסמים פנים אמיתיות.
5. תבדוק ב-fal את המחיר של מודל הווידאו ושל מודל התמונה, ותראה לי כמה תעלה הרצה לפני שאתה מריץ (קליפ של 5 שניות עם רפרנס לפנים יוצא בערך דולר, כולל פריימי הפתיחה).
6. פריים הפתיחה נוצר במודל לעריכת תמונה ב-fal, מהפריים שלי מקדימה, עם הסצנה החדשה, עם `aspect_ratio` של היחס שבחרתי (היחס של הקליפ נקבע לפי פריים הפתיחה), ועם המשפט `Keep his exact face and copy his real proportions, do not exaggerate any feature`.
7. בסוף הפרומפט של התמונה `Vertical 9:16 photo shot on an iPhone main camera, natural daylight, realistic colours, no colour grade, visible skin texture, no retouching, no text, no logos, no watermark`, וב-16:9 תכתוב `Horizontal 16:9 photo` במקום `Vertical 9:16 photo`.
8. תייצר שתי גרסאות של פריים הפתיחה ותיתן לי לבחור.
9. את הסרטון תייצר מפריים הפתיחה, עם 4 הפריימים האמיתיים כרפרנס לפנים (הפריים מקדימה ראשון), ובלי קול: אם יש הגדרה כמו `generate_audio`, תכבה אותה, כי אצל חלק מהמודלים היא דלוקה כברירת מחדל.
10. אם המודל קורא לרפרנס בשם, כמו `@Element1`, תוסיף לפרומפט `His face stays exactly the face of @Element1 the whole time.`
11. בפעולה עצמה תכתוב `smiling warmly` ולא `laughing`, ותסיים את הפרומפט ב-`Handheld iPhone footage, realistic, natural light, no cinematic grading. No subtitles. No text. No music.`
12. אם המודל מקבל רשימת דברים שאסור שיופיעו, תכתוב בה `face morphing, different person, deformed hands, extra fingers, cinematic colour grading, subtitles, watermark`.
13. אחרי הג'נרוט תוציא 6 פריימים לאורך הקליפ ותשווה את הפנים לרפרנסים, ואם הפנים זזות בסוף, תציע לחתוך לפני הרגע הזה.
14. בסוף תגדיל ל-1080 על 1920 (או 1920 על 1080) עם `scale=<רוחב>:<גובה>:force_original_aspect_ratio=increase:flags=lanczos,crop=<רוחב>:<גובה>`, תקודד ב-h264 עם crf 16 ותמסור בלי קול.
</בנייה>

<מלכודות>
רשימה של תווי פנים בפרומפט, כמו "פנים ארוכות" או "מצח גבוה", יוצאת מוגזמת בתוצאה.
מה שאסור שיופיע נכתב במפורש בפרומפט, למשל `no phone in his hands`, אחרת המודל מוסיף אותו מעצמו.
הרצה אחת בכל פעם, כי כל הרצה יורדת מהארנק.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, תבדוק שהחיבור ל-fal עובד, ותראה לי את 4 הפריימים, את המודל שבחרת, את המחיר ואת הפרומפטים לפני שאתה מייצר משהו.
</התחלה>

לפני שאתה מתמלל, תשאל אותי איזה סרטון, ובאיזו תיקייה נמצאים הקבצים שכבר יש לי.
תתמלל את הסרטון עם זמן לכל מילה, בעזרת `npx hyperframes transcribe <הקובץ> --language he --model large-v3`, ותציע לי רשימת בירולים כטבלה.
בכל שורה יהיו זמן ההתחלה והסוף, המשפט, המילה המרכזית והזמן שלה (לפיה נקבעת הכניסה), מה רואים בבירול, ומאיפה הוא מגיע (הקלטת מסך שאצלם, אנימציה שתבנה, קליפ AI, או קובץ שכבר יש בתיקייה).
אף פעם לא יותר מ-3 שניות ברצף של דיבור שלי למצלמה בלי בירול, וזום על הפנים לא נחשב בירול.
כל בירול מראה בדיוק את מה שנאמר באותו משפט, ואם אין משהו שמתאים באמת, תכתוב "חסר" במקום למלא בקליפ דומה.
שורה של "חסר" נספרת כחור בכיסוי, ותסמן אותה כך שאראה איפה חסר לי חומר.
אותו קליפ לא מופיע פעמיים, גם כקטע אחר מאותו קובץ.
הבירול נכנס בתוך המשפט שמזכיר אותו, בערך באמצע הדרך בין תחילת המשפט למילה המרכזית, ואף פעם לא יותר משנייה וחצי לפני המילה.
הקלטות מסך של החשבונות שלי אצלם בעצמי, ובשבילן תכתוב לי מה לצלם, כמה זמן ובאיזה רגע בסרטון, בלי לבנות צילום מסך מזויף.
תראה לי את הטבלה ותחכה לאישור לפני שאתה בונה או מייצר משהו.

<קלט>
תשאל אותי מה הקליפ או התמונה צריכים להראות, באיזה משפט בסרטון הם נכנסים, באיזה יחס (9:16 או 16:9) וכמה שניות.
אם הקליפ צריך להראות אותי, תבקש ממני תמונה חדה של הפנים שלי מקדימה ותעלה אותה ל-Higgsfield.
</קלט>

תבדוק ש-Higgsfield מחובר אליך, ואם לא, תסביר לי שב-claude.ai נכנסים ל-Customize ומשם ל-Connectors, לוחצים "+", בוחרים Add custom connector עם הכתובת `https://mcp.higgsfield.ai/mcp` ומתחברים לחשבון Higgsfield, ואז הוא מופיע לבד גם ב-Claude Code, תחת `/mcp`.
החיבור דורש מנוי בתשלום ב-Higgsfield, וכל ג'נרוט יורד מהקרדיטים.
תבדוק את יתרת הקרדיטים שלי, ותמליץ על מודל שמתאים לבקשה.
לפני כל ג'נרוט תבדוק את המחיר עם `get_cost: true`, שלא מריץ שום דבר, ותראה לי את הפרומפט, את המודל, את ההגדרות ואת המחיר בקרדיטים, ותחכה לאישור.
אם אין מספיק קרדיטים, תעצור ותגיד לי כמה חסר, בלי לנסות מודל אחר.
אם הקליפ מראה אותי, תבחר מודל שמקבל תמונת פנים כרפרנס, ותגיד לי מראש שאין הבטחה שהוא יקבל פנים אמיתיות.
הפרומפט באנגלית, נראה כמו צילום טלפון אמיתי באור טבעי, ונגמר ב-`No subtitles. No text. No music.`
בלי קול בקליפ, כי יש לי קריינות, וברירת המחדל מייצרת קול, אז תשלח `generate_audio: false`.
תייצר קליפ אחד בכל פעם, ולא כמה גרסאות במכה.
כשהקליפ מוכן, תוריד אותו לתיקייה, תוציא ממנו 4 פריימים ותבדוק פנים, ידיים וטקסט שהופיע בטעות לפני שאתה מראה לי.

<קלט>
תשאל אותי על שני דברים:
- איזו הקלטה לבדוק, אם יש בתיקייה יותר מאחת.
- מה להסתיר מעבר למיילים וטלפונים, למשל השם שלי, מספרי חשבון, או מחרוזת שמופיעה בנתיב של תיקייה.
אם עניתי רק "תמשיך", תסתיר מיילים וטלפונים בלבד.
זיהוי הטקסט של Mac לא קורא עברית, אז על כל דבר בעברית תגיד לי שהוא לא יימצא אוטומטית, ואסמן לך איפה הוא ומתי, או שתשתמש בזיהוי טקסט שקורא עברית.
</קלט>

<בנייה>
1. תוציא פריים לכל שנייה עם `ffmpeg -i <ההקלטה> -vf fps=1:round=up frames/%05d.png`, ככה פריים מספר N הוא בדיוק שנייה N-1.
2. תריץ על כל פריים זיהוי טקסט עם מיקום לכל מילה, בכמה תהליכים במקביל שכל אחד כותב לקובץ משלו, ובסוף תחבר אותם לטבלה אחת של מיקום וטקסט.
3. ב-Mac זה Vision של macOS, בסקריפט Swift קטן שמקומפל עם `swiftc -O`, עם `usesLanguageCorrection` כבוי, ציר y הפוך (Vision סופר מלמטה), ומיקום לכל מילה מ-`boundingBox(for:)`.
4. בווינדוס זה Tesseract (`winget install UB-Mannheim.TesseractOCR`, ואז `tesseract <תמונה> <פלט> tsv`, ולעברית חבילת השפה heb), דרך שלא נבדקה.
5. תחפש בטבלה עם regex מיילים, מספרי טלפון ואת כל המחרוזות שנתתי לך, גם כשהן חלק מנתיב או מכתובת, וגם טלפון שנקרא הפוך, כמו 0000000-050, כי בשורה בעברית Vision הופך לפעמים את החלקים.
6. סביב כל ממצא תסרוק שוב ב-5 פריימים לשנייה, משנייה לפניו ועד שנייה אחריו.
7. תאחד רק ממצאים של אותו טקסט שזז פחות מגובה שורה בין שתי דגימות, וטקסט שגולל מקבל אזור קצר לכל דגימה.
8. לכל אזור ריפוד של 8 פיקסלים, ו-0.6 שניות לפני ואחרי (או 1.3 שניות לממצא שנמצא רק בפריים לשנייה).
9. כל אזור נשאר לפחות פיקסל אחד בתוך המסך מכל צד, אחרת delogo נכשל.
10. מכל האזורים תבנה שרשרת אחת של פילטרי `delogo`, כל אחד עם `enable` שמדליק אותו רק בזמן שלו.
11. תרנדר במעבר אחד עם `-c:v libx264 -preset veryfast -crf 23`, תעתיק את הקול כמו שהוא, ותשמור ליד המקור באותו שם עם `_redacted` בסוף.
12. תריץ את זיהוי הטקסט מחדש על הקובץ החדש: פריים לשנייה על הכל, 5 פריימים לשנייה בחלונות, וכל פריים בשנייה שסביב תחילת וסוף כל אזור, כדי לתפוס טקסט שמחליק פנימה או החוצה בין הדגימות.
13. אם משהו עדיין נקרא, תוסיף אזור ידני אחד: מלבן שמכסה את כל המקומות שבהם הטקסט הופיע בחלון, ודולק לאורך כל החלון.
14. בסוף תבדוק שהקובץ תקין עם `ffmpeg -v error -i <הפלט> -f null -`, שצריך להחזיר אפס שורות.
</בנייה>

<מלכודות>
אל תבנה שכבה נפרדת של חיתוך וטשטוש לכל אזור, כי זה רץ פי 60 לאט יותר מ-delogo.
אל תשתמש ב-h264_videotoolbox, כי הוא הוציא קובץ עם שגיאות.
זיהוי הטקסט טועה בתו @ ובאותיות דומות, אז תאסוף את הדומיינים מהמיילים שמצאת ותחפש כל אחד גם לבד וגם עם אות אחת שונה.
כשהדומיין נמצא לבד, תטשטש את כל השורה שלו.
</מלכודות>

<התחלה>
תשאל אותי על הקלט, ולפני הרינדור תראה לי תמונה אחת לכל אזור, עם מסגרת אדומה סביבו והזמן שבו הוא דולק.
אחרי הרינדור תראה לי את התוצאה של הסריקה החוזרת.
</התחלה>

לפני שאתה מרנדר את כל הסרטון, תרנדר 15 שניות מהקטע הכי עמוס, ב-540 על 960 (או 960 על 540) וב-30 פריימים לשנייה, עם הקול.
אם לכלי אין דגל לטווח זמן ולהקטנה, כמו ב-`npx hyperframes render`, תעשה עותק זמני וקצר של הקומפוזיציה ברזולוציה הנמוכה שמכיל רק את הקטע הזה.
תראה לי את הטיוטה ותחכה לאישור של הסגנון.
אחרי שאישרתי, כל סבב תיקונים מרונדר באותה רזולוציה נמוכה.
את הרזולוציה המלאה תרנדר רק בסוף, כשאין יותר תיקונים.
תיקון קטן נבדק על פריים בודד או על כמה שניות סביבו, בלי לרנדר את כל הסרטון מחדש, וב-HyperFrames פריים בודד יוצא בלי רינדור עם `npx hyperframes snapshot --at <שנייה>`.

אתה לא צופה בווידאו, אז כל בדיקה שלך נעשית על פריימים.
אחרי כל רינדור תוציא פריים בכל רגע חשוב (כל כניסה של טקסט, כל אפקט וכל חיתוך), ותסתכל עליהם ברזולוציה מלאה.
סביב כל מעבר תוציא גם רצועה של פריים כל 0.1 שנייה, כדי לתפוס דברים שקופצים או קופאים.
בכל פריים תבדוק טקסט חתוך או בכיוון הלא נכון, משהו שמסתיר את הפנים, וחורים או קצוות בשכבות.
בדיקה אוטומטית שעברה לא מוכיחה שמשהו באמת על המסך, ולכן תמיד מסתכלים על הפריים עצמו.
כשאתה כותב שתיקנת משהו, תצרף את הפריים של הרגע שתוקן.

תפעיל סוכן נפרד שלא בנה את הסרטון, בתור מבקר קשוח של סטודיו לאנימציה.
תן לו את הבריף, פריים מכל סצנה ורצועת פריימים מכל מעבר, בלי ההסברים שלך.
הוא נותן ציון מתוך 100 לפי מחוון קבוע: ביצוע של כל מה שביקשתי, גימור, תנועה, טקסט ועברית, התאמה לסגנון, והיגיון פיזי.
לכל סצנה הוא מחזיר רשימת פגמים, ולכל פגם זמן, מה לא בסדר ותיקון עם מספרים.
אתה מתקן, ואותו מבקר בודק שוב, עד שהציון עובר 90.
אם אחרי שני סבבים הציון עדיין רחוק מ-90 ב-20 נקודות או יותר, תעצור ותביא לי את הפער ואת האפשרויות במקום לפתוח עוד סבבים.