The design language that makes your AI harness better at design.
JavaScript
Sync generated provider output
github-actions[bot]21168cbc8b5e
diff --git a/.agent/skills/impeccable/reference/harden.md b/.agent/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.agent/skills/impeccable/reference/harden.md+++ b/.agent/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.agents/skills/impeccable/reference/harden.md b/.agents/skills/impeccable/reference/harden.mdindex 07f3d90b2..894f06127 100644--- a/.agents/skills/impeccable/reference/harden.md+++ b/.agents/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.claude/skills/impeccable/reference/harden.md b/.claude/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.claude/skills/impeccable/reference/harden.md+++ b/.claude/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.cursor/skills/impeccable/reference/harden.md b/.cursor/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.cursor/skills/impeccable/reference/harden.md+++ b/.cursor/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.dsh/skills/impeccable/reference/harden.md b/.dsh/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.dsh/skills/impeccable/reference/harden.md+++ b/.dsh/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.gemini/skills/impeccable/reference/harden.md b/.gemini/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.gemini/skills/impeccable/reference/harden.md+++ b/.gemini/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.github/skills/impeccable/reference/harden.md b/.github/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.github/skills/impeccable/reference/harden.md+++ b/.github/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.grok/skills/impeccable/reference/harden.md b/.grok/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.grok/skills/impeccable/reference/harden.md+++ b/.grok/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.hermes/skills/impeccable/reference/harden.md b/.hermes/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.hermes/skills/impeccable/reference/harden.md+++ b/.hermes/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.kiro/skills/impeccable/reference/harden.md b/.kiro/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.kiro/skills/impeccable/reference/harden.md+++ b/.kiro/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.omp/skills/impeccable/reference/harden.md b/.omp/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.omp/skills/impeccable/reference/harden.md+++ b/.omp/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.opencode/skills/impeccable/reference/harden.md b/.opencode/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.opencode/skills/impeccable/reference/harden.md+++ b/.opencode/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.pi/skills/impeccable/reference/harden.md b/.pi/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.pi/skills/impeccable/reference/harden.md+++ b/.pi/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.qoder/skills/impeccable/reference/harden.md b/.qoder/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.qoder/skills/impeccable/reference/harden.md+++ b/.qoder/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.rovodev/skills/impeccable/reference/harden.md b/.rovodev/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.rovodev/skills/impeccable/reference/harden.md+++ b/.rovodev/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.trae-cn/skills/impeccable/reference/harden.md b/.trae-cn/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.trae-cn/skills/impeccable/reference/harden.md+++ b/.trae-cn/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.trae/skills/impeccable/reference/harden.md b/.trae/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.trae/skills/impeccable/reference/harden.md+++ b/.trae/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.veto/skills/impeccable/reference/harden.md b/.veto/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.veto/skills/impeccable/reference/harden.md+++ b/.veto/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/.vibe/skills/impeccable/reference/harden.md b/.vibe/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/.vibe/skills/impeccable/reference/harden.md+++ b/.vibe/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/cursor-plugin/skills/impeccable/reference/harden.md b/cursor-plugin/skills/impeccable/reference/harden.mdindex e4a979691..7f602c7cd 100644--- a/cursor-plugin/skills/impeccable/reference/harden.md+++ b/cursor-plugin/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) charactersdiff --git a/plugin/skills/impeccable/reference/harden.md b/plugin/skills/impeccable/reference/harden.mdindex 426b2d586..e7183cfab 100644--- a/plugin/skills/impeccable/reference/harden.md+++ b/plugin/skills/impeccable/reference/harden.md@@ -109,6 +109,25 @@ border-inline-end: 1px solid; /* Not border-right */[dir="rtl"] .arrow { transform: scaleX(-1); }```+**Arabic-script specifics** (Arabic, Persian, Urdu, Pashto, Kurdish):+- Preserve Zero-Width Non-Joiner (U+200C). Persian and Kurdish use ZWNJ between compound-word parts to break cursive joining while keeping the word together. A filter or sanitizer that strips it changes meaning. Never normalize it away.+- Handle Yeh and Kaf variants. Persian uses ی (U+06CC) and ک (U+06A9), while Arabic uses ي (U+064A) and ك (U+0643). Preserve the original form in storage. For search and validation, treat the corresponding letters as equivalent so that Arabic-keyboard input matches Persian text. Rejecting one variant locks out users whose keyboard sends the other.+- Support locale-aware digits. Persian (`fa-IR`) and Arabic locales use Eastern Arabic-Indic numerals (۰-۹ and ٠-٩). Use `Intl.NumberFormat` with the correct locale rather than hardcoding Western digits.++```javascript+// ✅ Locale-aware digit formatting+new Intl.NumberFormat('fa-IR').format(1234); // ۱٬۲۳۴+new Intl.NumberFormat('ar-SA').format(1234); // ١٬٢٣٤+```++- Respect calendar systems. Persian users expect the Solar Hijri (Jalali) calendar; many Arabic-speaking users expect the Hijri (Islamic) calendar. Use `Intl.DateTimeFormat` with the appropriate locale or calendar parameter.++```javascript+// ✅ Locale-appropriate calendar+new Intl.DateTimeFormat('fa-IR').format(new Date());+new Intl.DateTimeFormat('ar-SA-u-ca-islamic').format(new Date());+```+**Character set support**:- Use UTF-8 encoding everywhere- Test with Chinese/Japanese/Korean (CJK) characters