mdeck 3.7.1 → 3.9.0

package/examples/python/slides.hi.md

@@ -0,0 +1,492 @@
+---
+theme: academic
+meta:
+  title: "Python का परिचय"
+  author: "Tilman Schieber"
+  organization: "FHNW"
+  date: "2026-05-19"
+palette: paper
+---
+
+---
+:::meta
+layout: title
+id: python-for-life-sciences
+:::
+# लाइफ़ साइंसेज़ के लिए Python।
+## मास्टर्स के छात्रों के लिए क़दम-दर-क़दम परिचय।
+
+:::notes
+Python मॉड्यूल में आपका स्वागत है। इस सत्र के लिए प्रोग्रामिंग का कोई पूर्व अनुभव ज़रूरी नहीं है।
+
+- हम क़दम-दर-क़दम चलेंगे — सवाल पूछने में बिल्कुल न झिझकें
+- सारा कोड सीधे ब्राउज़र में चलता है — आज कुछ इंस्टॉल करने की ज़रूरत नहीं
+- लक्ष्य: अंत तक आप एक डेटासेट लोड कर पाएँगे, उसे जाँच पाएँगे और उसका प्लॉट बना पाएँगे
+:::
+
+---
+:::meta
+layout: focus
+eyebrow: Python क्यों?
+id: the-tools-your-field-uses-are-written-in
+:::
+# आपके क्षेत्र के टूल *Python में लिखे गए हैं*।
+
+:::notes
+डेटा पर आधारित काम के लिए Python शिक्षा जगत और उद्योग, दोनों में सबसे प्रचलित भाषा है।
+लाइफ़ साइंसेज़ भी अपवाद नहीं — बायोइन्फ़ॉर्मेटिक्स, इमेजिंग और क्लिनिकल डेटा विश्लेषण, सब Python पर चलते हैं।
+
+इसका इकोसिस्टम (NumPy, Pandas, Matplotlib, scikit-learn, BioPython) बेजोड़ है।
+बताएँ कि सांख्यिकी में R अब भी आम है, पर Python काफ़ी हद तक साझा भाषा बन चुकी है।
+:::
+
+---
+:::meta
+layout: chapter
+number: 1
+part: शुरुआत
+description: वेरिएबल, टाइप और आपके कोड की पहली पंक्तियाँ।
+id: variables-and-data-types
+:::
+# वेरिएबल और डेटा टाइप।
+
+:::notes
+यहीं से शुरू करें, भले ही छात्रों ने पहले थोड़ा Python देखा हो। हम बुनियाद से बनाते हैं।
+इस अध्याय का अनुमानित समय: 20 मिनट।
+:::
+
+---
+:::meta
+layout: split
+section: वेरिएबल
+id: variables-store-data
+props:
+  ratio: [3, 2]
+:::
+# वेरिएबल किसी मान का नाम है।
+:::slot left
+```python live editable copy
+name = "E. coli"
+genome_size = 4_641_652   # बेस पेयर
+gc_content = 0.506        # अनुपात
+
+print(name, genome_size, gc_content)
+print(f"GC content: {gc_content:.1%}")
+```
+:::
+:::slot right
+कोई घोषणा नहीं: Python मान से ही टाइप पहचान लेता है।
+
+**आज़माएँ:** `gc_content` को `0.65` कर दें और फिर से चलाएँ।
+:::
+
+:::notes
+वेरिएबल बस किसी मान से जुड़ा एक नाम है। Python टाइप अपने-आप पहचान लेता है।
+
+ध्यान दिलाएँ: न सेमीकोलन, न टाइप घोषणा, न अतिरिक्त ढाँचा। `f"…"` स्ट्रिंग किसी मान को टेक्स्ट के भीतर फ़ॉर्मैट करती है; `:.1%` अनुपात को प्रतिशत में दिखाता है।
+छात्रों को मान बदलकर फिर से चलाने के लिए प्रोत्साहित करें — लाइव ब्लॉक का यही मक़सद है।
+:::
+
+---
+:::meta
+section: डेटा टाइप
+id: four-types-cover-most-biology-data
+:::
+# चार टाइप से जीवविज्ञान का ज़्यादातर डेटा बन जाता है।
+
+:::steps
+- **`int`** — पूर्ण संख्याएँ: गिनती, स्थिति, इंडेक्स
+- **`float`** — दशमलव संख्याएँ: सांद्रता, p-मान, फ़ोल्ड चेंज
+- **`str`** — टेक्स्ट: जीन के नाम, सीक्वेंस, सैंपल ID
+- **`bool`** — True या False: सार्थकता फ़्लैग, गुणवत्ता फ़िल्टर
+:::
+
+:::notes
+एक बार में एक टाइप दिखाएँ और अगला दिखाने से पहले लैब से एक उदाहरण पूछें।
+
+ज़ोर दें कि बूलियन आमतौर पर तुलना से आते हैं, सीधे लिखे True/False से नहीं। अगली स्लाइड पर पूरे कमरे से पूछा जाएगा।
+:::
+
+---
+:::meta
+section: डेटा टाइप
+title: "पोल: p-मान का टाइप"
+id: poll-the-type-of-a-p-value
+:::
+# p-मान किस टाइप का होता है?
+
+<poll room="p-value" options="int|float|str|bool" answer="float" />
+
+:::notes
+आगे बढ़ने से पहले एक छोटी जाँच। फ़ोन QR कोड से जुड़ते हैं; डेक को `mdeck run slides.hi.md --network` से शुरू करें ताकि वे इस कंप्यूटर तक पहुँच सकें।
+
+उत्तर: `float`; बार के नीचे का टिक बटन इसे चिह्नित करता है। अगर कई लोगों ने `bool` चुना, तो वे उससे निकाले गए *सार्थकता फ़्लैग* (`p < 0.05`) के बारे में सोच रहे हैं: यह दिखाने का अच्छा मौक़ा है कि तुलना से बूलियन बनते हैं।
+:::
+
+---
+:::meta
+layout: split
+section: स्ट्रिंग
+props:
+  ratio: [3, 2]
+:::
+# स्ट्रिंग सीक्वेंस की तरह व्यवहार करती हैं।
+:::slot left
+```python live editable copy
+dna = "ATGCGTAAGCTTGAC"
+
+print("Length:     ", len(dna))
+print("First codon:", dna[:3])
+print("A count:    ", dna.count("A"))
+print("Reversed:   ", dna[::-1])
+print("As RNA:     ", dna.replace("T", "U"))
+```
+:::
+:::slot right
+स्लाइसिंग, गिनना और बदलना किसी भी टेक्स्ट पर एक जैसा काम करता है।
+
+**आज़माएँ:** `dna[-3:]` से आख़िरी कोडॉन प्रिंट करें।
+:::
+
+:::notes
+स्ट्रिंग सीक्वेंस होती हैं — आप उन्हें न्यूक्लियोटाइड सीक्वेंस की तरह ही काट सकते हैं।
+`replace("T", "U")` एक पंक्ति में ट्रांसक्रिप्शन है। ये अवधारणाएँ बाद में सीधे BioPython में काम आती हैं।
+:::
+
+---
+:::meta
+layout: chapter
+number: 2
+part: कलेक्शन
+description: एक साथ कई मान रखना और उन तक पहुँचना।
+:::
+# लिस्ट और डिक्शनरी।
+
+:::notes
+ज़्यादातर असली डेटा एक अकेला मान नहीं होता। लिस्ट और डिक्शनरी दो सबसे काम के कलेक्शन हैं।
+इस अध्याय का अनुमानित समय: 25 मिनट।
+:::
+
+---
+:::meta
+layout: split
+section: लिस्ट
+props:
+  ratio: [3, 2]
+:::
+# लिस्ट मानों को क्रम में रखती है।
+:::slot left
+```python live editable copy
+conc = [0.12, 0.45, 0.33, 0.78, 0.21]
+
+print("Samples:", len(conc))
+print("First:  ", conc[0])
+print("Last:   ", conc[-1])
+print("Sorted: ", sorted(conc))
+print("Mean:   ", sum(conc) / len(conc))
+```
+:::
+:::slot right
+गिनती शून्य से शुरू होती है: `conc[0]` पहला आइटम है, `conc[-1]` आख़िरी।
+
+**आज़माएँ:** छठा मान जोड़ें और देखें कि औसत कैसे बदलता है।
+:::
+
+:::notes
+लिस्ट क्रम बनाए रखती है और दोहराए गए मान भी रख सकती है। इंडेक्स 0 से शुरू होता है। ऋणात्मक इंडेक्स अंत से गिनते हैं।
+इनके लिए बढ़िया: टाइम सीरीज़, दोहराए गए माप, क्रम से होने वाले प्रोसेसिंग चरण।
+
+आम ग़लती: छात्र पहले आइटम के लिए इंडेक्स 1 लेते हैं। 0 से इंडेक्सिंग शुरू में ही पक्की करवाएँ।
+:::
+
+---
+:::meta
+layout: split
+section: डिक्शनरी
+props:
+  ratio: [3, 2]
+:::
+# डिक्शनरी मानों को नाम से ढूँढती है।
+:::slot left
+```python live editable copy
+sample = {
+    "id": "S042",
+    "organism": "Mus musculus",
+    "tissue": "liver",
+    "weight_mg": 312,
+}
+
+print(sample["organism"])
+sample["weight_mg"] = 318   # एक फ़ील्ड बदलें
+print(sample)
+```
+:::
+:::slot right
+एक डिक्शनरी एक सैंपल का वर्णन करती है: कॉलम नंबर याद रखने की ज़रूरत नहीं।
+
+**आज़माएँ:** `"treated": True` जोड़ें।
+:::
+
+:::notes
+डिक्शनरी कुंजियों (keys) को मानों से जोड़ती है। संरचित रिकॉर्ड के लिए एकदम सही — एक डिक्शनरी = एक सैंपल।
+बाद में डिक्शनरियों की एक लिस्ट Pandas DataFrame बन जाती है। यह बीज अभी बो दें।
+:::
+
+---
+:::meta
+layout: chapter
+number: 3
+part: कंट्रोल फ़्लो
+description: फ़ैसले लेना और पूरे डेटा पर काम दोहराना।
+:::
+# फ़ैसले और लूप।
+
+:::notes
+ये दो संरचनाएँ — if और for — डेटा प्रोसेसिंग स्क्रिप्ट के ज़्यादातर तर्क को संभाल लेती हैं।
+इस अध्याय का अनुमानित समय: 25 मिनट।
+:::
+
+---
+:::meta
+layout: split
+section: शर्तें
+props:
+  ratio: [3, 2]
+:::
+# `if` रास्ता चुनता है।
+:::slot left
+```python live editable copy
+p_value = 0.023
+fold_change = 2.4
+
+if p_value < 0.05 and fold_change > 2:
+    print("Significant upregulation")
+elif p_value < 0.05:
+    print("Significant, modest effect")
+else:
+    print("Not significant")
+```
+:::
+:::slot right
+इंडेंटेशन ही ब्लॉक है: Python ब्रेसेज़ नहीं, ख़ाली जगह का इस्तेमाल करता है।
+
+**आज़माएँ:** `fold_change = 1.5` कर दें।
+:::
+
+:::notes
+if / elif / else से हर तरह की शाखा बनती है। Python में इंडेंटेशन शैली की बात नहीं — यह सिंटैक्स है।
+दूसरी भाषाओं या R से आए छात्र यहाँ अटकते हैं। कोलन और इंडेंट अनिवार्य हैं।
+दिखाएँ कि कोलन भूलने पर क्या होता है: Python SyntaxError देता है।
+:::
+
+---
+:::meta
+layout: split
+section: लूप
+props:
+  ratio: [3, 2]
+:::
+# `for` हर आइटम के लिए एक काम दोहराता है।
+:::slot left
+```python live editable copy
+values = [1.2, 0.8, 2.1, 1.5, 0.9, 2.8]
+
+above = []
+for value in values:
+    if value > 1.0:
+        above.append(value)
+
+print(len(above), "of", len(values))
+print(above)
+```
+:::
+:::slot right
+लूप, जाँच, संग्रह: डेटा फ़िल्टर करने का मूल पैटर्न।
+
+**आज़माएँ:** इसके बजाय 1.0 से छोटे मान गिनें।
+:::
+
+:::notes
+for लूप किसी भी कलेक्शन पर चलते हैं। यह पैटर्न — लूप, जाँच, संग्रह — लगभग हर उस डेटा प्रोसेसिंग स्क्रिप्ट के केंद्र में है जो छात्र लिखेंगे।
+
+**D** दबाएँ और स्लाइड पर एक मान को लूप में ट्रेस करें: `value` में, `if` से होकर, `above` में। Escape से ड्रॉइंग बंद होती है; ड्रॉइंग स्लाइड के साथ बनी रहती है।
+:::
+
+---
+:::meta
+layout: chapter
+number: 4
+part: फ़ंक्शन
+description: तर्क को पैक करना ताकि आप उसे दोबारा इस्तेमाल और टेस्ट कर सकें।
+:::
+# फ़ंक्शन तर्क को दोबारा इस्तेमाल के लिए पैक करते हैं।
+
+:::notes
+फ़ंक्शन दोबारा इस्तेमाल होने लायक़ और टेस्ट करने लायक़ कोड की ओर पहला क़दम हैं।
+प्रेरणा के लिए: "आप यही गणना 200 सैंपल पर चलाएँगे — इसे एक बार लिखें, 200 बार बुलाएँ।"
+इस अध्याय का अनुमानित समय: 20 मिनट।
+:::
+
+---
+:::meta
+layout: split
+section: फ़ंक्शन
+props:
+  ratio: [3, 2]
+:::
+# फ़ंक्शन इनपुट को आउटपुट में बदलता है।
+:::slot left
+```python live editable copy
+def gc_content(seq):
+    """सीक्वेंस में GC का अनुपात लौटाता है।"""
+    gc = seq.count("G") + seq.count("C")
+    return gc / len(seq)
+
+for seq in ["ATGCGC", "AATTAA", "GCGCGC"]:
+    print(seq, f"{gc_content(seq):.0%}")
+```
+:::
+:::slot right
+इसे एक बार लिखें, फिर हर सैंपल पर बुलाएँ।
+
+**आज़माएँ:** लिस्ट में अपना सीक्वेंस जोड़ें।
+:::
+
+:::notes
+def, पैरामीटर, return — पूरा सिंटैक्स बस इतना है।
+समझाएँ: एक बार परिभाषित करें, अलग-अलग इनपुट के साथ कई बार बुलाएँ।
+docstring (def के बाद तीन उद्धरण चिह्नों वाली स्ट्रिंग) अच्छी आदत है — इसे जल्दी सिखाएँ।
+:::
+
+---
+:::meta
+layout: chapter
+number: 5
+part: वैज्ञानिक Python
+description: NumPy, Pandas और Matplotlib — तीन स्तंभ।
+:::
+# वैज्ञानिक स्टैक।
+
+:::notes
+यही तीन लाइब्रेरी Python को डेटा साइंस की सबसे प्रचलित भाषा बनाती हैं।
+व्यवहार में छात्र ज़्यादा शुद्ध Python नहीं लिखेंगे — वे इन्हीं का इस्तेमाल करेंगे।
+इस अध्याय का अनुमानित समय: 30 मिनट।
+:::
+
+---
+:::meta
+section: वैज्ञानिक Python
+:::
+# तीन लाइब्रेरी से लाइफ़ साइंसेज़ के ज़्यादातर काम हो जाते हैं।
+
+:::steps
+- **NumPy** — तेज़ ऐरे: पूरे डेटासेट पर एक साथ गणना
+- **Pandas** — तालिकाएँ: स्प्रेडशीट डेटा लोड करना, फ़िल्टर करना, समूह बनाना और सारांश निकालना
+- **Matplotlib** — प्लॉट, हर तत्व पर नियंत्रण के साथ
+:::
+
+:::notes
+गहराई में जाने से पहले एक संक्षिप्त झलक। मुख्य संदेश: ये लाइब्रेरी भारी काम संभालती हैं,
+इसलिए छात्र कम कोड लिखते हैं और शुद्ध Python लूप की तुलना में तेज़ और भरोसेमंद नतीजे पाते हैं।
+:::
+
+---
+:::meta
+layout: split
+section: NumPy
+props:
+  ratio: [3, 2]
+:::
+# NumPy पूरे ऐरे पर गणना करता है।
+:::slot left
+```python live copy
+import numpy as np
+
+m = np.array([1.2, 0.8, 2.1, 1.5, 0.9, 2.8])
+
+print("Mean:  ", m.mean().round(3))
+print("Std:   ", m.std().round(3))
+print("Median:", np.median(m))
+print("> 1.5: ", m[m > 1.5])
+```
+:::
+:::slot right
+`m[m > 1.5]` बिना लूप के फ़िल्टर करता है।
+
+इसकी तुलना दो अध्याय पहले वाले `for` लूप से करें।
+:::
+
+:::notes
+NumPy के ऑपरेशन पूरे ऐरे पर एक साथ लागू होते हैं — कोई लूप नहीं। यह तेज़ भी है और पढ़ने में आसान भी।
+इस वेक्टराइज़्ड शैली की आदत पड़ने में समय लगता है, पर इसे जल्दी सीखना फ़ायदेमंद है।
+डेमो: चलाने से पहले छात्रों से अनुमान लगवाएँ कि `m > 1.5` क्या लौटाता है।
+:::
+
+---
+:::meta
+layout: focus
+eyebrow: मुख्य सीख
+:::
+# ऑपरेशन अकेले मानों पर नहीं, *ऐरे* पर लिखें।
+
+:::notes
+शुद्ध Python से वैज्ञानिक Python की ओर सोच में यह सबसे अहम बदलाव है।
+इसे दोहराएँ, बैठने दें। जो छात्र इसे जल्दी आत्मसात कर लेते हैं, वे बाद में कहीं साफ़ कोड लिखते हैं।
+:::
+
+---
+:::meta
+layout: chapter
+number: 6
+part: आगे के क़दम
+description: यहाँ से आगे कहाँ जाएँ।
+id: keep-going
+:::
+# आगे बढ़ते रहें।
+
+:::notes
+एक रोडमैप के साथ समापन करें। परिचय के बाद छात्र अक्सर भटका हुआ महसूस करते हैं — उन्हें ठोस अगले क़दम दें
+और सबसे अच्छे मुफ़्त संसाधनों की ओर इशारा करें।
+:::
+
+---
+:::meta
+section: आगे के क़दम
+:::
+# आगे क्या सीखें।
+
+- **Pandas** — CSV लोड करना, पंक्तियाँ फ़िल्टर करना, समूहों के आँकड़े निकालना
+- **Matplotlib और Seaborn** — स्कैटर प्लॉट, हीटमैप, वॉल्केनो प्लॉट
+- **scikit-learn** — वर्गीकरण, क्लस्टरिंग, आयाम घटाना
+- **BioPython** — सीक्वेंस, BLAST, GenBank और PDB फ़ाइलें
+
+:::notes
+स्व-अध्ययन के लिए: सिंटैक्स के लिए आधिकारिक Python ट्यूटोरियल, डेटा के काम के लिए Pandas का दस्तावेज़।
+Kaggle के मुफ़्त Python और Pandas कोर्स बेहतरीन हैं और अपनी गति से किए जा सकते हैं।
+ख़ास तौर पर लाइफ़ साइंसेज़ के लिए: BioPython का दस्तावेज़ और Python for Bioinformatics पाठ्यपुस्तक (Bassi)।
+:::
+
+---
+:::meta
+layout: focus
+eyebrow: याद रखें
+:::
+# कोड लिखना सीखने का सबसे अच्छा तरीक़ा है *कोड लिखना*।
+
+:::notes
+इसी पर समापन करें। प्रोग्रामिंग एक कौशल है — इसमें अभ्यास लगता है। पहले कुछ हफ़्ते धीमे लगते हैं,
+फिर बात बैठ जाती है। रोज़ अभ्यास के लिए प्रोत्साहित करें, चाहे छोटी स्क्रिप्ट ही क्यों न हों। अभ्यास-प्रश्नों की ओर इशारा करें।
+:::
+
+---
+:::meta
+layout: title
+:::
+# सवाल?
+## धन्यवाद — अब अपने लैपटॉप खोलिए।
+
+:::notes
+सवालों के लिए समय छोड़ें।
+छात्रों को याद दिलाएँ कि कोर्स सामग्री कहाँ मिलेगी और आपसे कैसे संपर्क करें।
+अगले सत्र में Pandas और असली डेटासेट लोड करना शामिल होगा।
+:::

package/examples/showcase/slides.md

@@ -350,6 +350,39 @@ The underline and the circle on this slide were drawn with the pen and saved; th
 On an iPad, pair it from the launch page: you draw and steer there while the laptop drives the projector.
 :::
 
+---
+:::meta
+layout: split
+hotspots: auto
+id: zoom-in-on-a-part
+:::
+# Zoom in on a part
+:::slot left
+```markdown
+:::meta
+hotspots: auto
+:::
+```
+
+In the presenter view, press a **number** to zoom into that part. The same number, **0** or **Escape** goes back.
+:::
+:::slot right
+| Layer | Who owns it |
+|---|---|
+| Words | You |
+| Look | The theme |
+
+$$
+A = \pi r^2
+$$
+:::
+
+:::notes
+The numbered keys show on this slide only here in the presenter view, never on the projector. Press 2 for the table, 3 for the formula; the audience window flies along. The arrow keys leave the zoom and move on in one press.
+
+`hotspots: auto` finds pictures, code, tables, formulas and callouts. Put it in the deck's settings at the top to have keys on every slide, or write `marked` to give keys only to parts marked `data-hotspot`. H switches the keys off and on during the talk.
+:::
+
 ---
 # Which part will you try first?
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdeck",
-  "version": "3.7.1",
+  "version": "3.9.0",
   "type": "module",
   "description": "Write slides as a plain text file, present them in the browser, share them as one HTML file or PDF.",
   "license": "MIT",

package/skills/write-slides/SKILL.md

@@ -44,6 +44,7 @@ meta:
   date: "2026-09-16"
 bibliography: refs.bib  # optional: .bib, CSL-JSON or Hayagriva; cite [@key, p. 3] or @key, list with <bibliography />
 csl: apa                # optional: apa, vancouver, harvard1 or a .csl file
+hotspots: auto          # optional: number keys zoom in on pictures, code and tables while presenting; marked: only data-hotspot parts
 ---
 
 ---

package/src/build/config.js

@@ -38,7 +38,7 @@ export function baseConfig(slidesPath, { selfContained = false, defaultView = 'd
   return {
     configFile: false,
     root: runtimeRoot,
-    plugins: [preact(), slidesPlugin(abs, source === undefined ? {} : { source })],
+    plugins: [preact(), slidesPlugin(abs, source === undefined ? { languages: true } : { source })],
     // Deck-local components live outside the framework root and have no
     // node_modules of their own, so their preact imports must resolve back to
     // the framework's copy — and to the *same* instance, or hooks break.

package/src/build/slidesPlugin.js

@@ -15,6 +15,7 @@ import { assertDrawings } from './drawings.js'
 import { marked } from 'marked'
 import { scanTags, replaceTagsIn, withAttribute } from '../core/tags.js'
 import { resolveBibliography, sampleBibliography } from './bibliography.js'
+import { languageOfFile, languageFiles } from '../core/languages.js'
 
 const VIRTUAL_ID = 'virtual:slides'
 const RESOLVED_ID = '\0virtual:slides'
@@ -217,12 +218,19 @@ export function deckLookOnly(registry, deckConfig = {}) {
   return { ...registry, themes: { [theme.id]: theme }, palettes: palette ? { [palette.id]: registry.palettes[palette.id] } : {} }
 }
 
+// The same deck in its other languages (talk.en.md beside talk.de.md), for
+// the presenter view's language switch: `[{ lang, file }]`, or none.
+export function deckLanguages(abs) {
+  try { return languageFiles(basename(abs), readdirSync(dirname(abs))).map(({ lang, file }) => ({ lang, file: resolve(dirname(abs), file) })) } catch { return [] }
+}
+
 // `editor` keeps the page alive while `mdeck edit` rewrites the deck: deck
 // changes only invalidate the module, validation errors are warnings, and
 // extension changes are announced instead of forcing a reload. `source` is
 // the deck's text where there is no file (`mdeck design`, on the sample deck);
-// `slidesPath` then only says where its folder is.
-export function slidesPlugin(slidesPath, { inlineImages = false, inlineMedia = false, editor = false, stripNotes = false, stripActivities = false, ink = true, results = true, embedFonts: embedThemeFonts = false, deckLook = false, source: given = null } = {}) {
+// `slidesPath` then only says where its folder is. `languages` also brings
+// the deck's other languages along, for `mdeck run`; a built file has one.
+export function slidesPlugin(slidesPath, { languages = false, inlineImages = false, inlineMedia = false, editor = false, stripNotes = false, stripActivities = false, ink = true, results = true, embedFonts: embedThemeFonts = false, deckLook = false, source: given = null } = {}) {
   const abs = resolve(slidesPath)
   const readDeck = () => given ?? readFileSync(abs, 'utf-8')
   const watchDeck = context => { if (given === null) context.addWatchFile(abs) }
@@ -231,6 +239,10 @@ export function slidesPlugin(slidesPath, { inlineImages = false, inlineMedia = f
     return stripActivities ? stripActivitiesFrom(shared).source : shared
   }
   const inkPath = inkFileFor(abs)
+  // The language the file name gives, for a deck that sets no `lang`.
+  const fileLanguage = given === null ? languageOfFile(basename(abs))?.lang ?? null : null
+  const otherLanguages = () => languages && given === null ? deckLanguages(abs).filter(({ file }) => file !== abs) : []
+  let languageWatch = []
   const resultsPath = resultsFileFor(abs)
   const extensionDirs = extensionRoots(abs).map(root => root.dir)
   let componentDirs = componentFolders(abs, readDeck()).map(folder => folder.dir)
@@ -306,7 +318,20 @@ export function slidesPlugin(slidesPath, { inlineImages = false, inlineMedia = f
         if (errors.length && !editor) throw new Error(formatDiagnostics(errors, abs))
         if (diagnostics.length) this.warn(formatDiagnostics(diagnostics, abs))
         const source = maybeInlineAssets(sourceFor(raw), abs, { inlineImages, inlineMedia })
-        return `export default ${JSON.stringify(source)}`
+        // The other languages are read as they are: `mdeck check` checks each file.
+        const others = otherLanguages()
+        languageWatch = others.map(({ file }) => file)
+        for (const file of languageWatch) this.addWatchFile(file)
+        for (const { file } of others) {
+          const found = validateDeck(parseSlides(readFileSync(file, 'utf-8')), {
+            layouts: manifestsOf(registry, 'layout'), themes: manifestsOf(registry, 'theme'), palettes: manifestsOf(registry, 'palette'),
+          })
+          if (found.length) this.warn(formatDiagnostics(found, file))
+        }
+        const translations = others.length && fileLanguage
+          ? { [fileLanguage]: source, ...Object.fromEntries(others.map(({ lang, file }) => [lang, maybeInlineAssets(sourceFor(readFileSync(file, 'utf-8')), file, { inlineImages, inlineMedia })])) }
+          : {}
+        return `export default ${JSON.stringify(source)}\nexport const language = ${JSON.stringify(fileLanguage)}\nexport const languages = ${JSON.stringify(translations)}`
       }
       // The deck's saved ink (<deck>.drawings.json), scaled to its design size.
       // Builds bundle it, so the reader view and PDFs show it too.
@@ -385,7 +410,7 @@ export function slidesPlugin(slidesPath, { inlineImages = false, inlineMedia = f
       if (!/(^|[\/])index\.html$/.test(context.filename ?? context.path ?? '')) return html
       let config = {}
       try { config = parseSlides(readDeck()).deckConfig ?? {} } catch {}
-      const lang = config.lang
+      const lang = config.lang ?? fileLanguage
       if (typeof lang === 'string' && /^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/.test(lang)) html = html.replace(/<html lang="[^"]*"/, `<html lang="${lang}"`)
       if (embedThemeFonts) {
         const theme = loadRegistry(abs).themes[config.theme ?? 'neue']?.manifest
@@ -414,6 +439,11 @@ export function slidesPlugin(slidesPath, { inlineImages = false, inlineMedia = f
         reload(server, [RESOLVED_INK_ID], changed)
         return []
       }
+      if (languageWatch.includes(changed)) {
+        invalidate(server, [RESOLVED_ID])
+        if (!editor) server.ws.send({ type: 'full-reload' })
+        return []
+      }
       if (bibFiles.includes(changed)) {
         invalidate(server, [RESOLVED_BIB_ID])
         if (editor) return bibUpdate(server)

package/src/cli/index.js

@@ -22,6 +22,7 @@ import { renderPdf, attachPdf, findChrome } from '../build/pdf.js'
 import { installSkill, readSkill, TARGETS } from './skill.js'
 import { runPackages } from './themes.js'
 import { ManifestError, KINDS } from '../extensions/manifest.js'
+import { paramKind } from '../extensions/params.js'
 
 import { frameworkRoot } from '../paths.js'
 import { parseSlides } from '../core/parseSlides.js'
@@ -523,6 +524,9 @@ if (command === 'new') {
       console.log(`    ${c.cyan}${record.id}${c.reset} — ${record.title} ${c.dim}(${record.source})${record.description ? ' ' + record.description : ''}${c.reset}`)
       // What a theme suits, from its guide; --json has the whole guide.
       if (record.manifest?.guide?.suits) console.log(`      ${c.dim}Suits: ${record.manifest.guide.suits.join(' · ')}${c.reset}`)
+      // The settings a deck may change under params:, with the kind of value each takes.
+      const params = Object.entries(record.manifest?.params ?? {})
+      if (params.length) console.log(`      ${c.dim}Settings: ${params.map(([name, param]) => name + paramKind(param)).join(' · ')}${c.reset}`)
     }
   }
 

package/src/cli/themes.js

@@ -34,6 +34,8 @@ function looksOf(registry, catalogue) {
       // The oldest mdeck it works with, for the gallery's install note.
       ...(registry.themes[theme.id]?.package?.mdeck ? { mdeck: registry.themes[theme.id].package.mdeck } : {}),
       palette: theme.palette, appearance: theme.appearance ?? 'light', palettes: palettesFor(theme, palettes).map(p => p.id), ...(theme.guide ? { guide: theme.guide } : {}),
+      // Its settings, for the gallery's controls: token, default, kind and range.
+      ...(Object.keys(theme.params ?? {}).length ? { params: theme.params } : {}),
       ...(icons.get(theme.id) ? { icon: icons.get(theme.id) } : {}) })),
     palettes: Object.values(palettes).map(palette => ({ id: palette.id, title: palette.title, description: palette.description ?? '', builtIn: builtIn.has(palette.id + ':p'),
       ...(palette.theme ? { theme: palette.theme } : {}), light: colours(palette.light), dark: colours(palette.dark) })),