sashite-epin 2.0.0 → 2.2.0

data/README.md

@@ -1,37 +1,17 @@
-# Epin.rb
+# epin.rb
 
 [![Version](https://img.shields.io/github/v/tag/sashite/epin.rb?label=Version&logo=github)](https://github.com/sashite/epin.rb/tags)
 [![Yard documentation](https://img.shields.io/badge/Yard-documentation-blue.svg?logo=github)](https://rubydoc.info/github/sashite/epin.rb/main)
-![Ruby](https://github.com/sashite/epin.rb/actions/workflows/main.yml/badge.svg?branch=main)
-[![License](https://img.shields.io/github/license/sashite/epin.rb?label=License&logo=github)](https://github.com/sashite/epin.rb/raw/main/LICENSE.md)
+[![CI](https://github.com/sashite/epin.rb/actions/workflows/ruby.yml/badge.svg?branch=main)](https://github.com/sashite/epin.rb/actions)
+[![License](https://img.shields.io/github/license/sashite/epin.rb?label=License&logo=github)](https://github.com/sashite/epin.rb/raw/main/LICENSE)
 
-> **EPIN** (Extended Piece Identifier Notation) implementation for the Ruby language.
+> **EPIN** (Extended Piece Identifier Notation) implementation for Ruby.
 
-## What is EPIN?
+## Overview
 
-EPIN (Extended Piece Identifier Notation) extends [PIN](https://sashite.dev/specs/pin/1.0.0/) by adding a **derivation marker** to track piece style in cross-style games.
+This library implements the [EPIN Specification v1.0.0](https://sashite.dev/specs/epin/1.0.0/).
 
-**EPIN is simply: PIN + optional style derivation marker (`'`)**
-
-This gem implements the [EPIN Specification v1.0.0](https://sashite.dev/specs/epin/1.0.0/) with a minimal compositional API.
-
-## Core Concept
-
-```ruby
-# EPIN is just PIN + derived flag
-pin = Sashite::Pin.parse("K^")
-epin = Sashite::Epin.new(pin, derived: false)
-
-epin.to_s      # => "K^" (native)
-epin.pin       # => PIN::Identifier instance
-epin.derived?  # => false
-
-# Mark as derived
-derived_epin = epin.mark_derived
-derived_epin.to_s # => "K^'" (derived from opposite side's style)
-```
-
-**That's it.** All piece attributes come from the PIN component.
+EPIN extends [PIN](https://sashite.dev/specs/pin/1.0.0/) with an optional derivation marker (`'`) that flags whether a piece uses a native or derived style.
 
 ## Installation
 
@@ -49,48 +29,64 @@ gem install sashite-epin
 ## Dependencies
 
 ```ruby
-gem "sashite-pin" # Piece Identifier Notation
+gem "sashite-pin"  # Piece Identifier Notation
 ```
 
-## Quick Start
+## Usage
+
+### Parsing (String → Identifier)
+
+Convert an EPIN string into an `Identifier` object.
 
 ```ruby
 require "sashite/epin"
 
-# Parse an EPIN string
+# Standard parsing (raises on error)
 epin = Sashite::Epin.parse("K^'")
-epin.to_s # => "K^'"
-
-# Access five fundamental attributes through PIN component + derived flag
-epin.pin.type          # => :K (Piece Name)
-epin.pin.side          # => :first (Piece Side)
-epin.pin.state         # => :normal (Piece State)
-epin.pin.terminal?     # => true (Terminal Status)
-epin.derived?          # => true (Piece Style: derived vs native)
-
-# PIN component is a full PIN::Identifier
-epin.pin.enhanced?     # => false
-epin.pin.letter        # => "K"
+epin.to_s  # => "K^'"
+
+# Access PIN attributes through the component
+epin.pin.abbr       # => :K
+epin.pin.side       # => :first
+epin.pin.state      # => :normal
+epin.pin.terminal?  # => true
+
+# Access derivation status
+epin.derived?  # => true
+epin.native?   # => false
+
+# PIN component is a full Sashite::Pin::Identifier instance
+epin.pin.enhanced?      # => false
+epin.pin.first_player?  # => true
+
+# Invalid input raises ArgumentError
+Sashite::Epin.parse("invalid")  # => raises ArgumentError
 ```
 
-## Basic Usage
+### Formatting (Identifier → String)
 
-### Creating Identifiers
+Convert an `Identifier` back to an EPIN string.
 
 ```ruby
-# Parse from string
-epin = Sashite::Epin.parse("K^")      # Native
-epin = Sashite::Epin.parse("K^'")     # Derived
-
-# Create from PIN component
+# From PIN component
 pin = Sashite::Pin.parse("K^")
-epin = Sashite::Epin.new(pin, derived: false)  # Native
-epin = Sashite::Epin.new(pin, derived: true)   # Derived
+epin = Sashite::Epin::Identifier.new(pin)
+epin.to_s  # => "K^"
 
-# Validate
-Sashite::Epin.valid?("K^")     # => true
-Sashite::Epin.valid?("K^'")    # => true
-Sashite::Epin.valid?("K^''")   # => false (multiple markers)
+# With derivation
+epin = Sashite::Epin::Identifier.new(pin, derived: true)
+epin.to_s  # => "K^'"
+```
+
+### Validation
+
+```ruby
+# Boolean check
+Sashite::Epin.valid?("K")         # => true
+Sashite::Epin.valid?("+R^'")      # => true
+Sashite::Epin.valid?("invalid")   # => false
+Sashite::Epin.valid?("K''")       # => false
+Sashite::Epin.valid?("K'^")       # => false
 ```
 
 ### Accessing Components
@@ -99,53 +95,31 @@ Sashite::Epin.valid?("K^''")   # => false (multiple markers)
 epin = Sashite::Epin.parse("+R^'")
 
 # Get PIN component
-epin.pin                       # => #<Pin::Identifier type=:R state=:enhanced terminal=true>
-epin.pin.to_s                  # => "+R^"
+epin.pin       # => #<Sashite::Pin::Identifier +R^>
+epin.pin.to_s  # => "+R^"
 
 # Check derivation
-epin.derived? # => true
+epin.derived?  # => true
+epin.native?   # => false
 
 # Serialize
-epin.to_s # => "+R^'"
-```
-
-### Five Fundamental Attributes
-
-All attributes accessible via PIN component + derived flag:
-
-```ruby
-epin = Sashite::Epin.parse("+R^'")
-
-# From PIN component (4 attributes)
-epin.pin.type                  # => :R (Piece Name)
-epin.pin.side                  # => :first (Piece Side)
-epin.pin.state                 # => :enhanced (Piece State)
-epin.pin.terminal?             # => true (Terminal Status)
-
-# From EPIN (5th attribute)
-epin.derived? # => true (Piece Style: native vs derived)
+epin.to_s  # => "+R^'"
 ```
 
-## Transformations
+### Transformations
 
-All transformations return new immutable instances:
-
-### Change Derivation Status
+All transformations return new immutable instances.
 
 ```ruby
 epin = Sashite::Epin.parse("K^")
 
-# Mark as derived
-derived = epin.mark_derived
-derived.to_s # => "K^'"
-
-# Mark as native
-native = derived.unmark_native
-native.to_s # => "K^"
+# Derivation transformations
+epin.derive.to_s  # => "K^'"
+epin.native.to_s  # => "K^"
 
-# Toggle
-toggled = epin.with_derived(!epin.derived?)
-toggled.to_s # => "K^'"
+# Replace PIN component
+new_pin = Sashite::Pin.parse("+Q^")
+epin.with_pin(new_pin).to_s  # => "+Q^"
 ```
 
 ### Transform via PIN Component
@@ -153,506 +127,151 @@ toggled.to_s # => "K^'"
 ```ruby
 epin = Sashite::Epin.parse("K^'")
 
-# Replace PIN component
-new_pin = epin.pin.with_type(:Q)
-epin.with_pin(new_pin).to_s # => "Q^'"
-
-# Change type
-epin.with_pin(epin.pin.with_type(:Q)).to_s # => "Q^'"
+# Change abbr
+epin.with_pin(epin.pin.with_abbr(:Q)).to_s  # => "Q^'"
 
 # Change state
-epin.with_pin(epin.pin.with_state(:enhanced)).to_s # => "+K^'"
-
-# Remove terminal marker
-epin.with_pin(epin.pin.with_terminal(false)).to_s # => "K'"
+epin.with_pin(epin.pin.enhance).to_s  # => "+K^'"
 
 # Change side
-epin.with_pin(epin.pin.flip).to_s # => "k^'"
-```
-
-### Multiple Transformations
-
-```ruby
-epin = Sashite::Epin.parse("K^")
+epin.with_pin(epin.pin.flip).to_s  # => "k^'"
 
-# Transform PIN and derivation
-transformed = epin
-              .with_pin(epin.pin.with_type(:Q).with_state(:enhanced))
-              .mark_derived
-
-transformed.to_s # => "+Q^'"
+# Remove terminal
+epin.with_pin(epin.pin.non_terminal).to_s  # => "K'"
 ```
 
-## Component Queries
+### Component Queries
 
-Use the PIN component API directly:
+Use the PIN API directly:
 
 ```ruby
 epin = Sashite::Epin.parse("+P^'")
 
-# PIN queries (name, side, state, terminal)
-epin.pin.type                  # => :P
-epin.pin.side                  # => :first
-epin.pin.state                 # => :enhanced
-epin.pin.terminal?             # => true
-epin.pin.first_player?         # => true
-epin.pin.enhanced?             # => true
-epin.pin.letter                # => "P"
-epin.pin.prefix                # => "+"
-epin.pin.suffix                # => "^"
-
-# EPIN queries (style)
-epin.derived?                  # => true
-epin.native?                   # => false
+# PIN queries
+epin.pin.abbr          # => :P
+epin.pin.side          # => :first
+epin.pin.state         # => :enhanced
+epin.pin.terminal?     # => true
+epin.pin.first_player? # => true
+epin.pin.enhanced?     # => true
+
+# EPIN queries
+epin.derived?  # => true
+epin.native?   # => false
 
 # Compare EPINs
 other = Sashite::Epin.parse("+P^")
-epin.pin.same_type?(other.pin)     # => true (both P)
-epin.pin.same_state?(other.pin)    # => true (both enhanced)
-epin.same_derivation?(other)       # => false (different derivation)
+epin.pin.same_abbr?(other.pin)   # => true
+epin.pin.same_state?(other.pin)  # => true
+epin.same_derived?(other)        # => false
 ```
 
 ## API Reference
 
-### Main Module
-
-```ruby
-# Parse EPIN string
-Sashite::Epin.parse(epin_string) # => Epin::Identifier
-
-# Create from PIN component
-Sashite::Epin.new(pin, derived: false) # => Epin::Identifier
-
-# Validate string
-Sashite::Epin.valid?(epin_string) # => Boolean
-```
-
-### Identifier Class
-
-#### Core Methods (6 total)
-
-```ruby
-# Creation
-Sashite::Epin.new(pin, derived: false) # Create from PIN + derivation flag
-
-# Component access
-epin.pin                        # => PIN::Identifier
-epin.derived?                   # => Boolean
-
-# Serialization
-epin.to_s # => "K^'" or "K^"
-
-# PIN replacement
-epin.with_pin(new_pin) # New EPIN with different PIN
-
-# Derivation transformation
-epin.mark_derived               # Mark as derived (add ')
-epin.unmark_native              # Mark as native (remove ')
-epin.with_derived(boolean)      # Set derivation explicitly
-```
-
-#### Convenience Queries
-
-```ruby
-epin.native?                    # !derived?
-epin.same_derivation?(other)    # Compare derivation status
-```
-
-#### Equality
-
-```ruby
-epin1 == epin2 # True if both PIN and derived flag equal
-```
-
-**That's the entire API.** Everything else uses the PIN component API directly.
-
-## Format Specification
-
-### Structure
-```
-<pin>[']
-```
-
-Where:
-- `<pin>` is any valid PIN token
-- `'` is the optional derivation marker
-
-### Grammar (BNF)
-```bnf
-<epin> ::= <pin> | <pin> "'"
-
-<pin> ::= ["+" | "-"] <letter> ["^"]
-<letter> ::= "A" | ... | "Z" | "a" | ... | "z"
-```
-
-### Regular Expression
-```ruby
-/\A[-+]?[A-Za-z]\^?'?\z/
-```
-
-## Examples
-
-### Basic Identifiers
+### Types
 
 ```ruby
-# Native pieces (no derivation marker)
-native_king = Sashite::Epin.parse("K^")
-native_king.pin.type          # => :K
-native_king.derived?          # => false
-
-# Derived pieces (with derivation marker)
-derived_king = Sashite::Epin.parse("K^'")
-derived_king.pin.type         # => :K
-derived_king.derived?         # => true
-
-# Enhanced pieces
-enhanced_rook = Sashite::Epin.parse("+R'")
-enhanced_rook.pin.enhanced?   # => true
-enhanced_rook.derived?        # => true
-
-# Diminished pieces
-diminished_pawn = Sashite::Epin.parse("-p")
-diminished_pawn.pin.diminished?  # => true
-diminished_pawn.native?          # => true
-```
-
-### Cross-Style Scenarios
-
-Assume first player uses Chess style, second player uses Makruk style:
-
-```ruby
-# First player pieces
-chess_king = Sashite::Epin.parse("K^")      # Native Chess king
-makruk_pawn = Sashite::Epin.parse("P'")     # Derived Makruk pawn (foreign)
-
-chess_king.native?            # => true (uses own style)
-makruk_pawn.derived?          # => true (uses opponent's style)
-
-# Second player pieces
-makruk_king = Sashite::Epin.parse("k^")     # Native Makruk king
-chess_pawn = Sashite::Epin.parse("p'")      # Derived Chess pawn (foreign)
-
-makruk_king.native?           # => true
-chess_pawn.derived?           # => true
-```
-
-### Component Manipulation
-
-```ruby
-# Start with native king
-epin = Sashite::Epin.parse("K^")
-
-# Convert to derived
-derived = epin.mark_derived
-derived.to_s # => "K^'"
-
-# Change to queen (keep derivation)
-queen = derived.with_pin(derived.pin.with_type(:Q))
-queen.to_s # => "Q^'"
-
-# Enhance (keep derivation)
-enhanced = derived.with_pin(derived.pin.with_state(:enhanced))
-enhanced.to_s # => "+K^'"
-
-# Change side (keep derivation)
-opponent = derived.with_pin(derived.pin.flip)
-opponent.to_s # => "k^'"
-
-# Back to native
-native = derived.unmark_native
-native.to_s # => "K^"
-```
-
-### Working with PIN Component
-
-```ruby
-epin = Sashite::Epin.parse("+R^'")
-
-# Extract PIN component
-pin = epin.pin # => "+R^"
-
-# Transform PIN
-new_pin = pin.with_type(:B).with_state(:normal) # => "B^"
-
-# Create new EPIN with transformed PIN
-new_epin = epin.with_pin(new_pin)
-new_epin.to_s # => "B^'"
-
-# Multiple PIN transformations
-complex_pin = pin
-              .with_type(:Q)
-              .with_state(:diminished)
-              .with_terminal(false)
-              .flip
-
-epin.with_pin(complex_pin).to_s # => "-q'"
-```
-
-### Immutability
-
-```ruby
-original = Sashite::Epin.parse("K^")
-
-# All transformations return new instances
-derived = original.mark_derived
-changed_pin = original.with_pin(original.pin.with_type(:Q))
-
-# Original unchanged
-original.to_s                 # => "K^"
-derived.to_s                  # => "K^'"
-changed_pin.to_s              # => "Q^"
-
-# Components are immutable
-pin = original.pin
-pin.frozen?                   # => true
-original.frozen?              # => true
-```
-
-## Attribute Mapping
-
-EPIN exposes all five fundamental attributes from the Sashité Game Protocol:
-
-| Protocol Attribute | EPIN Access | Example |
-|-------------------|-------------|---------|
-| **Piece Name** | `epin.pin.type` | `:K` (King), `:R` (Rook) |
-| **Piece Side** | `epin.pin.side` | `:first`, `:second` |
-| **Piece State** | `epin.pin.state` | `:normal`, `:enhanced`, `:diminished` |
-| **Terminal Status** | `epin.pin.terminal?` | `true`, `false` |
-| **Piece Style** | `epin.derived?` | `false` (native), `true` (derived) |
-
-## Design Principles
-
-### 1. Pure Composition
-
-EPIN doesn't reimplement PIN features — it extends PIN minimally:
-
-```ruby
-# EPIN is just PIN + derived flag
-class Identifier
+# Identifier represents a parsed EPIN combining PIN with derivation status.
+class Sashite::Epin::Identifier
+  # Creates an Identifier from a PIN component.
+  # Raises ArgumentError if the PIN is invalid.
+  #
+  # @param pin [Sashite::Pin::Identifier] PIN component
+  # @param derived [Boolean] Derived status
+  # @return [Identifier]
   def initialize(pin, derived: false)
-    @pin = pin
-    @derived = !!derived
-  end
-end
-```
-
-### 2. Absolute Minimal API
-
-**6 core methods only:**
-1. `new(pin, derived: false)` — create from PIN
-2. `pin` — get PIN component
-3. `derived?` — check derivation
-4. `to_s` — serialize
-5. `with_pin(new_pin)` — replace PIN
-6. `with_derived(boolean)` — change derivation
-
-Everything else uses the PIN component API directly.
-
-### 3. Component Transparency
-
-Access PIN directly — no wrappers:
-
-```ruby
-# Use PIN API directly
-epin.pin.type
-epin.pin.with_type(:Q)
-epin.pin.enhanced?
-epin.pin.flip
-
-# No need for wrapper methods like:
-# epin.type
-# epin.with_type
-# epin.enhanced?
-# epin.flip
-```
 
-### 4. Backward Compatibility
-
-Every valid PIN is a valid EPIN (without derivation marker):
-
-```ruby
-# All PIN identifiers work as EPIN
-pin_tokens = ["K", "+R", "-p", "K^", "+R^"]
-pin_tokens.each do |token|
-  epin = Sashite::Epin.parse(token)
-  epin.native?                 # => true
-  epin.to_s == token           # => true
+  # Returns the PIN component.
+  #
+  # @return [Sashite::Pin::Identifier]
+  def pin
+
+  # Returns true if derived style.
+  #
+  # @return [Boolean]
+  def derived?
+
+  # Returns true if native style.
+  #
+  # @return [Boolean]
+  def native?
+
+  # Returns the EPIN string representation.
+  #
+  # @return [String]
+  def to_s
 end
 ```
 
-### 5. Immutability
-
-All instances frozen. Transformations return new instances:
+### Parsing
 
 ```ruby
-epin1 = Sashite::Epin.parse("K^")
-epin2 = epin1.mark_derived
-epin1.frozen?                 # => true
-epin2.frozen?                 # => true
-epin1.equal?(epin2)           # => false
+# Parses an EPIN string into an Identifier.
+# Raises ArgumentError if the string is not valid.
+#
+# @param string [String] EPIN string
+# @return [Identifier]
+# @raise [ArgumentError] if invalid
+def Sashite::Epin.parse(string)
 ```
 
-## Semantics
-
-### Native vs Derived
-
-In cross-style games:
-- **Native piece**: Uses its own side's style (no `'` marker)
-- **Derived piece**: Uses opponent's style (`'` marker present)
+### Validation
 
 ```ruby
-# Chess vs Makruk match
-# First player = Chess, Second player = Makruk
-
-"K"   # First player king in Chess style (native)
-"K'"  # First player king in Makruk style (derived from opponent)
-"k"   # Second player king in Makruk style (native)
-"k'"  # Second player king in Chess style (derived from opponent)
+# Reports whether string is a valid EPIN.
+#
+# @param string [String] EPIN string
+# @return [Boolean]
+def Sashite::Epin.valid?(string)
 ```
 
-### Style Derivation Logic
+### Transformations
 
 ```ruby
-# Assume: first=Chess, second=Makruk
-
-epin = Sashite::Epin.parse("P")
-# Piece Side: first
-# Style: Chess (first's native) → Native piece
-
-epin = Sashite::Epin.parse("P'")
-# Piece Side: first
-# Style: Makruk (second's native) → Derived piece
+# PIN replacement (returns new Identifier)
+def with_pin(new_pin)  # => Identifier with different PIN
 
-epin = Sashite::Epin.parse("p")
-# Piece Side: second
-# Style: Makruk (second's native) → Native piece
-
-epin = Sashite::Epin.parse("p'")
-# Piece Side: second
-# Style: Chess (first's native) → Derived piece
+# Derivation transformations
+def derive  # => Identifier with derived: true
+def native  # => Identifier with derived: false
 ```
 
-## Error Handling
-
-```ruby
-# Invalid EPIN string
-begin
-  Sashite::Epin.parse("invalid")
-rescue ArgumentError => e
-  e.message # => "Invalid EPIN string: invalid"
-end
+### Errors
 
-# Multiple derivation markers
-begin
-  Sashite::Epin.parse("K''")
-rescue ArgumentError => e
-  # Invalid format
-end
+All parsing and validation errors raise `ArgumentError` with descriptive messages:
 
-# PIN validation errors delegate
-begin
-  Sashite::Epin.parse("KK'")
-rescue ArgumentError => e
-  # PIN validation error
-end
-```
+| Message | Cause |
+|---------|-------|
+| `"invalid derivation marker"` | Derivation marker misplaced or duplicated |
+| `"invalid PIN component: ..."` | PIN parsing failed |
 
-## Performance Considerations
+## PIN Compatibility
 
-### Efficient Composition
+Every valid PIN is a valid EPIN (native by default):
 
 ```ruby
-# PIN component created once
-pin = Sashite::Pin.parse("K^")
-epin = Sashite::Epin.new(pin, derived: true)
-
-# Accessing components is O(1)
-epin.pin         # => direct reference
-epin.derived?    # => direct boolean check
-
-# No overhead from method delegation
-epin.pin.type # => direct method call on PIN component
-```
-
-### Transformation Patterns
-
-```ruby
-epin = Sashite::Epin.parse("K^'")
-
-# Pattern 1: Change derivation only
-epin.unmark_native
-
-# Pattern 2: Change PIN only
-epin.with_pin(epin.pin.with_type(:Q))
-
-# Pattern 3: Change both
-new_pin = epin.pin.with_type(:Q)
-epin.with_pin(new_pin).unmark_native
-
-# Pattern 4: Complex PIN transformation
-new_pin = epin.pin
-              .with_type(:Q)
-              .with_state(:enhanced)
-              .flip
-epin.with_pin(new_pin).mark_derived
-```
-
-## Comparison with PIN
-
-### What EPIN Adds
-
-```ruby
-# PIN: 4 attributes
-pin = Sashite::Pin.parse("K^")
-pin.type          # Piece Name
-pin.side          # Piece Side
-pin.state         # Piece State
-pin.terminal?     # Terminal Status
-
-# EPIN: 5 attributes (PIN + style)
-epin = Sashite::Epin.parse("K^'")
-epin.pin.type     # Piece Name
-epin.pin.side     # Piece Side
-epin.pin.state    # Piece State
-epin.pin.terminal? # Terminal Status
-epin.derived? # Piece Style (5th attribute)
+%w[K +R -p K^ +R^].each do |pin_token|
+  epin = Sashite::Epin.parse(pin_token)
+  epin.native?  # => true
+  epin.to_s     # => pin_token
+end
 ```
 
-### When to Use EPIN vs PIN
-
-**Use PIN when:**
-- Single-style games (both players use same style)
-- Style information not needed
-- Maximum compatibility required
-
-**Use EPIN when:**
-- Cross-style games (different styles per player)
-- Pieces can change style (promotion to foreign piece)
-- Need to track native vs derived pieces
-
-## Design Properties
+## Design Principles
 
-- **Rule-agnostic**: Independent of game mechanics
-- **Pure composition**: Extends PIN minimally
-- **Minimal API**: Only 6 core methods
-- **Component transparency**: Direct PIN access
-- **Backward compatible**: All PIN tokens valid
-- **Immutable**: Frozen instances
-- **Type-safe**: Full PIN type preservation
-- **Style-aware**: Tracks native vs derived
-- **Compact**: Single character overhead for derivation
+- **Pure composition**: EPIN composes PIN without reimplementing features
+- **Minimal API**: Core methods (`pin`, `derived?`, `native?`, `to_s`) plus transformations
+- **Component transparency**: Access PIN directly, no wrapper methods
+- **Immutable identifiers**: Frozen instances prevent mutation
+- **Ruby idioms**: `valid?` predicate, `to_s` conversion, `ArgumentError` for invalid input
 
 ## Related Specifications
 
-- [EPIN Specification v1.0.0](https://sashite.dev/specs/epin/1.0.0/) - Technical specification
-- [EPIN Examples](https://sashite.dev/specs/epin/1.0.0/examples/) - Usage examples
-- [PIN Specification v1.0.0](https://sashite.dev/specs/pin/1.0.0/) - Base component
-- [Sashité Game Protocol](https://sashite.dev/game-protocol/) - Foundation
+- [Game Protocol](https://sashite.dev/game-protocol/) — Conceptual foundation
+- [EPIN Specification](https://sashite.dev/specs/epin/1.0.0/) — Official specification
+- [EPIN Examples](https://sashite.dev/specs/epin/1.0.0/examples/) — Usage examples
+- [PIN Specification](https://sashite.dev/specs/pin/1.0.0/) — Base component
 
 ## License
 
-Available as open source under the [MIT License](https://opensource.org/licenses/MIT).
-
-## About
-
-Maintained by [Sashité](https://sashite.com/) — promoting chess variants and sharing the beauty of board game cultures.
+Available as open source under the [Apache License 2.0](https://opensource.org/licenses/Apache-2.0).