// Characters are NOT atomic. They're composed objects.
// Just like you wouldn't write a 10,000-line class,
// Chinese doesn't invent a unique shape for every concept.

interface Radical { category: string; }
interface PhoneticHint { sound: string; }

class 河 implements Water {
    left: Radical = 氵;      // water radical → meaning
    right: PhoneticHint = 可; // "kě" → sound hint (hé)
    meaning = "river";
}

// The radical tells you WHAT CATEGORY.
// The other component often hints at HOW IT SOUNDS.
// Two components. Meaning + sound. That's the pattern.

// The radical system is an interface hierarchy.
// ~200 radicals. ~50,000+ characters.
// Learn the interfaces and you can read the type signatures.

interface Water {}    // 氵 → wet things, liquids, flow
interface Wood {}     // 木 → trees, wood objects, plants
interface Fire {}     // 火/灬 → heat, cooking, burning
interface Mouth {}    // 口 → eating, drinking, speaking, sounds
interface Heart {}    // 心/忄 → emotions, thoughts, mental states
interface Speech {}   // 言/讠 → language, communication, words
interface Hand {}     // 手/扌 → actions done by hand
interface Metal {}    // 钅 → metals, tools, machines
interface Person {}   // 亻 → people, human actions
interface Foot {}     // 足 → movement, walking, paths

// When you see an unknown character, check the radical first.
// It's like checking what interface a class implements —
// you immediately know its category.

class LeftRight {
    left: Radical;       // usually the semantic radical
    right: Component;    // usually the phonetic hint
}

class TopBottom {
    top: Component;      // could be radical or phonetic
    bottom: Component;   // could be radical or phonetic
}

class Enclosure {
    outer: Component;    // the wrapper / container
    inner: Component;    // the enclosed content
}

// Like a wrapper component in React,
// or a container class in CSS.

// Phonetic components are like a base class with a sound property.
// Subclasses (characters) inherit the approximate sound
// and override the meaning via their radical.

abstract class 青_Family {
    abstract radical: Radical;
    sound ≈ "qīng";  // approximate — tone may vary
}

class 清 extends 青_Family { radical = 氵; meaning = "clear (water)"; }
class 请 extends 青_Family { radical = 讠; meaning = "please (speech)"; }
class 晴 extends 青_Family { radical = 日; meaning = "sunny (sun)"; }
class 情 extends 青_Family { radical = 忄; meaning = "emotion (heart)"; }
class 睛 extends 青_Family { radical = 目; meaning = "eye (sight)"; }

// Five characters. One pattern. Know the system, halve the memorization.

// Character math: the ultimate composition patterns
compose("日", "月")         // → 明 = bright      (sun + moon)
compose("木", "木")         // → 林 = grove        (tree + tree)
compose("木", "木", "木")   // → 森 = forest       (tree * 3)
compose("人", "人")         // → 从 = follow       (person + person)
compose("人", "人", "人")   // → 众 = crowd        (person * 3)
compose("亻", "木")         // → 休 = rest         (person + tree)
compose("宀", "女")         // → 安 = peace        (roof + woman)
compose("宀", "豕")         // → 家 = home         (roof + pig)
compose("田", "力")         // → 男 = man          (field + strength)
compose("女", "子")         // → 好 = good         (woman + child)
compose("小", "大")         // → 尖 = sharp        (small + big)
compose("手", "目")         // → 看 = look         (hand + eye)

// These aren't random pairings. They're engineering.
// Each composition tells a micro-story.

# Makefile: building the character 国 (country)
# Build order: outside-in, close last

国: 囗_frame 玉_contents 囗_seal
    @echo "Character assembled: 国"

囗_frame:         # Step 1-2: draw left side, then top
    stroke vertical-left
    stroke horizontal-top

玉_contents:      # Step 3-6: fill the inside (玉 = jade)
    stroke horizontal
    stroke horizontal
    stroke vertical
    stroke dot

囗_seal:          # Step 7: close the bottom — always last
    stroke horizontal-bottom

# Total: 8 strokes, strict dependency order.
# Reorder them and the character looks wrong —
# like a binary compiled out of order.

/**
 * Chinese Character Composition Model v1.0
 *
 * ARCHITECTURE:
 * 1. Characters are COMPOSED, not atomic
 *    - Built from radicals (semantic) + components (often phonetic)
 *    - ~200 radicals cover the standard library
 *
 * 2. Radicals are INTERFACES
 *    - 氵Water, 木 Wood, 火 Fire, 口 Mouth, 心 Heart,
 *      讠Speech, 扌Hand, 钅Metal, 亻Person, 足 Foot...
 *    - The radical declares the semantic category
 *
 * 3. Layout patterns are STRUCTURAL
 *    - LeftRight (most common): radical | component
 *    - TopBottom: component / component
 *    - Enclosure: outer { inner }
 *
 * 4. Phonetic components are INHERITED SOUND
 *    - 青 → 清 请 晴 情 睛 (all sound ~qīng)
 *    - The radical changes meaning; the phonetic hints at sound
 *
 * 5. Some characters are PURE COMPOSITION
 *    - 明 = 日 + 月 = bright
 *    - 休 = 亻+ 木 = rest
 *    - 森 = 木 * 3 = forest
 *
 * 6. Stroke order is BUILD ORDER
 *    - Top→bottom, left→right, outside→inside, close last
 *    - Consistent rules. Like a makefile.
 *
 * KEY INSIGHT:
 * Chinese characters are not 50,000 random pictures.
 * They're ~200 interfaces composed into objects.
 * Learn the parts. Read the architecture. Guess the meaning.
 *
 * NEXT MODULE: The Standard Library
 * → Core vocabulary: the packages you import to get things done.
 */