# PROJECT.md - Nulltongue Forge

## Mission

Build **Nulltongue Forge**, a self-hosted web application for showcasing, editing, learning, compiling, versioning, and packaging the Nulltongue language/font project. It must also work as a practical general font editor for imported fonts.

The application is intentionally a **simple one-shot build**: PHP serves the application and orchestrates local font tools; HTML/CSS/vanilla JavaScript provide the UI; HTML5 Canvas provides the vector glyph editor. No Node runtime, SPA framework, or database is required for v1.

### Required stack

- PHP 8.2+
- HTML5
- CSS3
- Vanilla JavaScript (ES2020+)
- HTML5 Canvas 2D
- File-based project storage
- Python 3 + fontTools for binary font inspection/building
- Brotli/WOFF2 support
- Optional FontForge CLI if installed
- Official Nerd Fonts patcher or compatible local Nerd-glyph import helper

Target Linux first. It should run under PHP's development server, Apache+PHP, or nginx+PHP-FPM.

---

## Product goals

Nulltongue Forge must provide one integrated workflow:

1. **Showcase** the current Nulltongue release, language, books, reading tests, glyph charts, specimens, and release history.
2. **Load and inspect** TTF/OTF/WOFF/WOFF2 fonts.
3. **Edit glyphs** with a real vector/spline Canvas editor.
4. **Edit Nulltongue language metadata**: phonetic syllabary, IPA, phonemes, logographs, grammar, vocabulary, notes, and examples.
5. **Manage font weights/styles**, starting with Regular 400, Bold 700, and ExtraBold 800.
6. **Import Nerd Font symbols** selectively or patch a complete Nerd variant.
7. **Preview terminal behavior** including TUI box drawing and Nerd Font glyphs.
8. **Compile fonts** to TTF/OTF/WOFF/WOFF2.
9. **Validate** cmap, naming, monospacing, outlines, weight metadata, and protected Unicode ranges.
10. **Create versioned releases** and ZIP a complete `Nulltongue_Language_Kit_vX.Y.Z.zip`.

The app must also support creating a new project from another imported font. Nulltongue-specific panels may be disabled for generic projects.

---

# 1. Nulltongue invariants

## 1.1 UTF-8 stays ordinary

Nulltongue is a visual writing/font layer, not a custom character encoding. The underlying text stays Unicode.

Example:

- keyboard key: `a`
- Unicode: `U+0061`
- stored character: `a`
- displayed outline: Nulltongue glyph for `a`
- Nulltongue syllable: `ZA`

Never silently remap text to Private Use Area codepoints for ordinary Nulltongue letters.

## 1.2 Lowercase syllabary

Canonical mapping:

| Keys | Family | Sounds |
|---|---|---|
| a-e | Z | ZA ZE ZI ZO ZU |
| f-j | K | KA KE KI KO KU |
| k-o | R | RA RE RI RO RU |
| p-t | T | TA TE TI TO TU |
| u-y | SH | SHA SHE SHI SHO SHU |
| z | special | ZEN |

Each lowercase glyph stores:

- character/key
- Unicode codepoint
- glyph name
- syllable
- IPA
- consonant family
- vowel class
- phoneme description
- pronunciation notes
- mnemonic/construction notes
- learner notes

## 1.3 Uppercase logographs

`A-Z` are independent logographs, **not capital forms of lowercase**. They should look and behave like a separate semantic writing system.

Each stores:

- character/key
- Unicode
- glyph name
- concept
- semantic category
- definition
- mnemonic
- related vocabulary root
- learner notes

## 1.4 Digits and punctuation

Digits preserve their decimal values but receive separate alien/circuit numeral shapes. Printable punctuation can be visually redesigned while retaining its Unicode meaning.

## 1.5 Protected Unicode

Higher Unicode must remain untouched unless explicitly edited. Important protected groups include:

- box drawing
- block elements
- arrows
- Braille
- combining marks
- non-Latin scripts
- emoji/fallback behavior
- Powerline / Nerd Font ranges unless deliberately patching them

The build system must support a project-level **replacement whitelist** and **preservation rules**.

## 1.6 Monospace

All terminal builds must keep one cell advance width for editable ASCII. The editor must show and validate:

- UPM/em square
- advance width
- left/right side bearing
- baseline
- x-height
- cap height
- ascender
- descender
- centerline
- cell boundaries

---

# 2. Font family / weight model

Nulltongue v0.3 starts with:

- **Nulltongue Mono Regular** - weight class 400
- **Nulltongue Mono Bold** - weight class 700
- **Nulltongue Mono ExtraBold** - weight class 800
- matching **Nulltongue Mono Nerd** styles

The editor must understand styles as related masters/instances rather than unrelated files.

Suggested source layout:

```text
font/styles/
  Regular/
  Bold/
  ExtraBold/
```

Each glyph can have:

- independent outlines per style, or
- a linked generated style derived from another master with a weight expansion recipe.

UI requirements:

- style selector always visible in Glyph Editor
- compare Regular/Bold/ExtraBold overlays
- copy outline to another weight
- interpolate/derive weight where feasible
- “unlink generated style” before manual editing
- style-specific metrics override
- OS/2 weight class editor
- name table preview

A glyph diff should be able to compare both **versions** and **weights**.

---

# 3. Application navigation

Main navigation:

1. Home
2. Glyph Editor
3. Character Map
4. Language
5. Terminal Preview
6. Font Inspector
7. Nerd Fonts
8. Documents
9. Build
10. Releases
11. Settings

Use a server-rendered PHP shell with JavaScript-enhanced workspaces. Avoid a giant SPA.

---

# 4. Home / showcase

Show the active project/release with:

- branding and version
- selected weight/style
- live editable text
- plain-font vs Nulltongue side-by-side preview
- Regular/Bold/ExtraBold comparison strip
- lowercase syllabary chart
- uppercase logograph chart
- digit/punctuation chart
- terminal specimen
- Nerd Font icon specimen
- downloadable fonts
- reference dictionary
- learning textbook
- beginner/moderate/hard reading tests
- changelog/release history

Load WOFF2 through `@font-face` for the browser preview.

---

# 5. Glyph Editor - Canvas requirements

This is the core feature.

## 5.1 Coordinate system

Use font/world units, not screen pixels.

- origin at font baseline
- font Y increases upward
- Canvas renderer converts world coordinates to screen coordinates
- high-DPI/Retina-aware rendering
- zoom should not change geometry precision

## 5.2 Geometry model

Represent outlines as explicit paths:

```json
{
  "contours": [
    {
      "closed": true,
      "nodes": [
        {
          "x": 200,
          "y": 500,
          "kind": "line|quadratic|cubic",
          "in": {"x": 0, "y": 0},
          "out": {"x": 0, "y": 0},
          "smooth": false
        }
      ]
    }
  ]
}
```

Support:

- line segments
- quadratic Beziers
- cubic Beziers
- open/closed contours
- multiple contours
- counters/holes
- components/references where practical

## 5.3 Tools

Required toolbar:

- Select
- Node Select
- Pen
- Line
- Quadratic Bezier
- Cubic Bezier
- Rectangle
- Ellipse
- Polygon
- Knife/Split
- Join
- Close Path
- Corner Node
- Smooth Node
- Symmetric Handles
- Measure
- Guide
- Pan

Required operations:

- drag point/handle
- multi-select
- marquee select
- add/delete node
- merge nodes
- split segment
- convert segment type
- align/distribute
- rotate/scale/flip
- duplicate
- nudge 1 unit / 10 units

## 5.4 Snap / no-snap

Prominent toolbar toggle:

- `SNAP`
- `NO SNAP`

Snap targets:

- grid
- baseline
- x-height
- cap height
- ascender
- descender
- centerline
- advance boundaries
- side bearings
- other nodes
- extrema
- horizontal/vertical alignment
- intersections
- handles
- custom guides

Configurable snap tolerance in screen pixels. Modifier key temporarily disables snapping.

## 5.5 Grid and guides

Grid sizes:

`1, 2, 5, 10, 20, 25, 50` font units plus custom.

Grid visibility and grid snapping are independent.

Guides:

- horizontal
- vertical
- angled
- global
- glyph-local
- lock/unlock
- rename
- hide/show

## 5.6 Measurements

Show CAD-like live dimensions:

- cursor X/Y
- selected point X/Y
- delta X/Y during movement
- segment length
- angle
- bounding box W/H
- distance between nodes
- distance to baseline/cap/x-height
- LSB/RSB
- advance width
- extrema
- component scale/rotation

Allow temporary ruler measurements between arbitrary points. Render extension lines, arrowheads, and labels in a Canvas overlay.

## 5.7 Layers/overlays

At minimum:

- background/reference image/SVG
- donor outline
- ghost glyph
- current outline
- guides
- grid
- measurements
- node/handle overlay

Ghost/reference controls:

- choose glyph
- choose weight
- choose version
- opacity slider
- offset
- lock

Use ghost glyphs for family consistency (`ZA/ZE/ZI...`) and weight comparison.

## 5.8 Class visualization

Editor UI colors only:

- lowercase syllabary: cyan
- uppercase logographs: purple
- digits: amber
- punctuation: pale blue
- Nerd Font: green
- inherited Unicode: gray
- custom/imported: magenta

Never encode these UI colors into the actual font glyph.

## 5.9 Undo/redo

Command-based history, at least 100 actions per glyph/session.

Include geometry, transforms, metric changes, imports, and important guide operations.

Shortcuts:

- Ctrl/Cmd+Z
- Ctrl/Cmd+Shift+Z
- Ctrl/Cmd+Y

## 5.10 Autosave

Dirty changes autosave via fetch/AJAX to project source. Autosave never mutates a published release directory.

---

# 6. Character Map

Searchable grid across loaded cmap.

Filters:

- lowercase
- uppercase
- digits
- punctuation
- ASCII
- Latin
- box drawing
- arrows
- Braille
- Powerline
- Nerd Font
- PUA
- supplementary PUA
- missing
- modified
- inherited

Each cell shows:

- rendered glyph
- key/character
- U+ codepoint
- glyph name
- category
- style availability
- dirty/changed marker

Search by character, codepoint, Unicode/glyph name, Nulltongue sound, concept, or Nerd icon name.

---

# 7. Import any font

Support uploads:

- TTF
- OTF
- WOFF
- WOFF2

Modes:

1. **Create project from font**
2. **Merge selected glyphs into current project**
3. **Use as reference/ghost font only**

Do not implement binary OpenType parsing from scratch in browser JavaScript. PHP calls Python/fontTools to normalize the uploaded font into project JSON.

Extract:

- name records
- cmap
- glyph order/names
- UPM
- metrics
- outlines
- tables
- kerning/features where practical
- OS/2 weight/width
- variable axes if present

Uploaded files must be validated and stored outside webroot.

---

# 8. SVG interoperability

Per glyph:

- Export SVG
- Import SVG
- Replace outline from SVG
- Add SVG as locked reference

Import controls:

- fit to em
- preserve scale
- center horizontally
- baseline align
- flip Y
- simplify path
- quantize points

---

# 9. Language editor

Tabs:

- Syllabary
- Phonemes
- Logographs
- Vocabulary
- Grammar
- Examples
- Learning Material Metadata

## Syllabary fields

- key
- glyph preview per weight
- sound
- IPA
- family
- vowel
- pronunciation note
- mnemonic
- notes

## Logograph fields

- key
- glyph preview per weight
- concept
- category
- description
- related vocabulary root
- mnemonic

## Vocabulary fields

- word
- rendered preview
- pronunciation
- IPA
- part of speech
- English meaning
- definition
- derivation
- example sentence
- difficulty
- tags

Grammar can be Markdown-backed but should have sections for word order, negation, questions, plural, modifiers, compounds, derivation, possession, tense/aspect, and technical-register conventions.

---

# 10. Nerd Font manager

Provide a searchable glyph catalog containing:

- icon name
- codepoint
- source set
- category/tags
- rendered preview

Support Powerline, Font Awesome, Devicons, Octicons, Material, Codicons, Seti, Weather, and other installed Nerd Font sets.

Two workflows:

1. **Patch Complete Nerd Font** - invoke approved Nerd Fonts patcher/helper.
2. **Selective Import** - choose individual symbols and merge them.

Collision policy must never overwrite silently. Show:

- Keep Current
- Replace
- Remap
- Skip
- Apply to All

Nerd glyphs should preserve terminal cell metrics in Mono/Nerd builds.

---

# 11. Terminal Preview

Resizable fake terminal with presets:

- shell
- tmux
- Neovim
- btop
- git
- tree
- systemctl
- Rust
- C
- PHP
- JSON
- Markdown

Controls:

- font style/weight
- size
- line height
- letter spacing
- foreground/background
- Core/Nerd font
- split plain/Nulltongue
- custom text
- cursor simulation
- optional ligature toggle

Always include a TUI torture test:

```text
+ Unicode box drawing in actual preview, not ASCII fallback
CPU blocks, arrows, Braille, Powerline, PUA icons, long paths, digits, punctuation
```

Validate cell alignment visually.

---

# 12. Font Inspector

Show:

- family/subfamily
- PostScript name
- version
- copyright/license
- UPM
- ascender/descender/line gap
- glyph count
- cmap count
- Unicode ranges
- fixed-pitch status
- weight/width class
- fsSelection/macStyle
- tables
- OpenType features
- variable axes

Warnings:

- inconsistent ASCII advances
- name/weight mismatch
- duplicate cmap
- missing `.notdef`
- open/invalid contours
- out-of-bounds outline
- bad side bearings
- overlapping/duplicate points
- protected-Unicode modification
- Nerd Font collision

---

# 13. Build page

Checkbox output matrix:

- Core TTF
- Core OTF
- Core WOFF
- Core WOFF2
- Nerd TTF
- Nerd OTF
- Nerd WOFF
- Nerd WOFF2
- all styles / selected styles
- source ZIP
- specimens
- checksums
- build report
- complete Language Kit ZIP

Build into:

```text
storage/projects/<id>/builds/<version>/
```

Never build into source directories.

---

# 14. Server-side toolchain

PHP is orchestration, not the outline compiler.

Recommended:

- Python 3
- fontTools
- Brotli
- WOFF2 tooling
- FontForge CLI optionally
- Nerd Fonts `font-patcher` or local import script

Harden command execution:

- fixed executable allowlist
- no raw shell concatenation
- `escapeshellarg()` if shell invocation is unavoidable
- randomized temporary directories
- timeout
- max upload/build size
- sanitized filenames

Synchronous builds are acceptable for v1 because the target is a self-hosted one-shot tool.

---

# 15. Build pipeline

```text
1. validate project
2. snapshot source
3. resolve selected weights/styles
4. compile glyph JSON to outlines
5. apply cmap
6. apply metrics
7. apply name/version/OS2 style metadata
8. compile TTF
9. validate TTF
10. export OTF
11. export WOFF
12. export WOFF2
13. create Nerd variants
14. validate terminal metrics / protected ranges
15. generate specimens
16. copy documents
17. copy learning materials
18. generate manifest
19. generate SHA256SUMS
20. generate build report
21. generate RELEASE.md
22. ZIP Language Kit
```

---

# 16. Validation requirements

Fail build for severe problems.

For Nulltongue:

- all intended printable ASCII glyphs exist
- SPACE remains valid
- all ASCII advances equal in Mono builds
- lowercase map complete
- uppercase map complete
- digits complete
- punctuation complete
- all requested weights exist and use correct OS/2 weight class
- family/subfamily/PostScript naming is internally consistent
- representative box drawing preserved
- representative arrows preserved
- representative Braille preserved
- Nerd variant contains representative PUA + supplementary PUA mappings
- no Nulltongue ASCII overwritten by Nerd patch
- version metadata matches release
- release version does not already exist

Emit both:

```text
build-report.json
build-report.html
```

---

# 17. Versioning

Use Semantic Versioning.

Examples:

- 0.3.0
- 0.3.1
- 0.4.0
- 1.0.0

Guidance:

- PATCH: fixes, no intentional mapping break
- MINOR: new font styles, glyph redesigns, new vocabulary/tools, compatible language growth
- MAJOR: breaking cmap/language semantics

Version appears in:

- project.json
- font name/version tables
- manifest
- release notes
- build directory
- ZIP filename

Published releases are immutable.

---

# 18. Release layout

```text
storage/releases/0.3.0/
  manifest.json
  RELEASE.md
  SHA256SUMS.txt
  fonts/
  books/
  learning-materials/
  source/
  specimens/
  website/
  Nulltongue_Language_Kit_v0.3.0.zip
```

Release UI shows date, changelog, changed glyphs, changed language entries, styles, artifacts, sizes, SHA-256, and validation result.

---

# 19. Language Kit ZIP contract

```text
Nulltongue_Language_Kit_vX.Y.Z/
  README.md
  PROJECT.md
  manifest.json
  RELEASE.md
  SHA256SUMS.txt
  licenses/
  fonts/
    ttf/
    otf/
    woff/
    woff2/
    nerd/
  source/
    project.json
    mapping.json
    glyphs/
    language/
  books/
  learning-materials/
  specimens/
  web/
```

Do not silently rename or omit existing learning documents from a release.

---

# 20. Document manager

Categories:

- reference books
- textbooks
- learning tests/materials
- specimens
- screenshots
- release notes
- licenses

Allow upload, rename, order, categorize, preview, and include/exclude from next release.

Do not implement PDF editing in v1.

---

# 21. Import existing Language Kit ZIP

Workflow:

1. upload ZIP
2. validate archive
3. reject absolute paths / `../` traversal / symlink tricks
4. extract to randomized temp directory
5. locate manifest/project metadata
6. show import summary
7. user confirms
8. import as a new project or new source version
9. never overwrite an existing release

---

# 22. Suggested project storage

```text
storage/projects/nulltongue/
  project.json
  mapping.json
  font/
    metadata.json
    metrics.json
    cmap.json
    features.fea
    styles/
      Regular/glyphs/
      Bold/glyphs/
      ExtraBold/glyphs/
  language/
    phonology.json
    grammar.md
    vocabulary.json
    lessons.json
  documents/
  learning-materials/
  assets/
  imports/
  builds/
```

Example `project.json`:

```json
{
  "id": "nulltongue",
  "name": "Nulltongue",
  "version": "0.3.0",
  "family": "Nulltongue Mono",
  "monospace": true,
  "styles": [
    {"name": "Regular", "weightClass": 400},
    {"name": "Bold", "weightClass": 700},
    {"name": "ExtraBold", "weightClass": 800}
  ],
  "nerdFont": true,
  "replacementRanges": [["U+0021", "U+007E"]],
  "preserve": ["box-drawing", "block-elements", "arrows", "braille", "non-latin"]
}
```

---

# 23. Suggested HTTP/API endpoints

```text
/api/project/load.php
/api/project/save.php
/api/project/import.php

/api/glyph/get.php
/api/glyph/save.php
/api/glyph/import-svg.php
/api/glyph/export-svg.php
/api/glyph/copy-weight.php

/api/font/upload.php
/api/font/inspect.php
/api/font/import.php

/api/nerd/catalog.php
/api/nerd/import.php
/api/nerd/patch.php

/api/build/start.php
/api/build/status.php
/api/build/report.php

/api/release/create.php
/api/release/list.php

/api/files/upload.php
/api/files/delete.php
/api/files/list.php
```

JSON response convention:

```json
{"ok":true,"data":{},"warnings":[]}
```

or:

```json
{"ok":false,"error":{"code":"INVALID_GLYPH","message":"Contour 2 is open."}}
```

---

# 24. Front-end organization

```text
public/
  index.php
  editor.php
  language.php
  preview.php
  build.php
  releases.php
  assets/
    css/
      app.css
      editor.css
    js/
      app.js
      api.js
      editor/
        canvas.js
        viewport.js
        geometry.js
        paths.js
        tools.js
        snapping.js
        guides.js
        measurements.js
        selection.js
        history.js
        renderer.js
        weights.js
      preview.js
```

Avoid one giant JS file.

Suggested PHP structure:

```text
src/
  App.php
  Config.php
  Http/
  Project/
  Font/
  Glyph/
  NerdFont/
  Build/
  Release/
  Storage/
  Security/
```

Composer autoloading is fine. Do not require Laravel/Symfony.

---

# 25. Security

Because the site accepts fonts and ZIPs:

- strict upload-size caps
- MIME + extension validation
- random temp paths
- ZIP-slip protection
- no executable uploads inside webroot
- CSRF tokens for writes
- HTML-escape all font metadata
- command allowlist
- safe subprocess arguments
- build timeout
- storage outside public directory
- Content Security Policy where practical
- optional simple password auth for non-local deployments

---

# 26. Keyboard shortcuts

Suggested:

```text
V             select
A             node tool
P             pen
L             line
R             rectangle
O             ellipse
G             guide
M             measure
S             toggle snap
Shift+G       toggle grid
H             guides show/hide
Space+drag    pan
+ / -         zoom
0             fit glyph
1             100%
Ctrl/Cmd+S    save
Ctrl/Cmd+Z    undo
Ctrl/Cmd+Shift+Z redo
Delete        delete selection
Arrow         nudge 1 unit
Shift+Arrow   nudge 10 units
```

Avoid browser shortcut conflicts where possible.

---

# 27. Status bar

Lowercase example:

```text
U+0061  a  ZA  | Regular 400 | 4 contours / 21 nodes | X:342 Y:614 | Advance:1233 | Snap:GRID+GUIDES | Zoom:240%
```

Uppercase:

```text
U+0041  A  SYSTEM | Bold 700 | ...
```

Nerd symbol:

```text
U+E0A0 nf-pl-branch | POWERLINE | ...
```

---

# 28. Diff modes

Glyph diff:

- current vs last save
- current vs release
- current vs donor
- Regular vs Bold
- Bold vs ExtraBold
- current vs imported reference

Views:

- overlay
- side-by-side
- blink
- difference highlight

Release diff shows:

- changed outlines
- changed mappings
- changed weights/styles
- language changes
- document changes
- Nerd glyph count changes
- font metadata changes

Use this data to draft `RELEASE.md`.

---

# 29. One-shot installation

Provide:

```text
./install.sh
```

It should:

1. verify PHP >= 8.2
2. verify Python 3
3. create writable storage/temp directories
4. verify/install-or-report Python fontTools/Brotli dependencies
5. discover optional Nerd Font patcher / FontForge
6. copy `.env.example` to `.env` if missing
7. print the command to run locally

Local run target:

```bash
php -S 127.0.0.1:8080 -t public
```

No frontend compilation step is allowed for the base application.

---

# 30. Acceptance criteria for v1

A fresh installation is considered successful only when it can:

1. open the Nulltongue project and current release;
2. switch among Regular, Bold, and ExtraBold;
3. render current webfonts live;
4. open any printable ASCII glyph in Canvas;
5. display baseline, x-height, cap height, em square, cell width, side bearings, grid, and guides;
6. add/move/delete line and Bezier nodes;
7. toggle snap/no-snap and configure snap targets;
8. display dimension/angle measurements;
9. undo/redo edits;
10. save and autosave glyph source;
11. compare glyph weights and versions;
12. import TTF/OTF/WOFF/WOFF2 as a new project;
13. browse imported cmap;
14. import selected glyphs from another font;
15. import/export SVG;
16. edit Nulltongue phonetic/logographic metadata;
17. search the Nerd Font catalog;
18. import selected Nerd glyphs and detect collisions;
19. generate a complete Nerd variant;
20. preview shell/TUI/code with the selected weight;
21. compile Regular/Bold/ExtraBold core TTF, OTF, WOFF, WOFF2;
22. compile matching Nerd variants;
23. validate fixed-width ASCII and protected Unicode;
24. generate checksums and a build report;
25. bump a semantic version;
26. package fonts, books, learning materials, source, licenses, specimen, and release notes into one versioned Language Kit ZIP;
27. refuse to overwrite a published release;
28. import a prior Language Kit safely.

---

# 31. Non-goals for v1

Do not spend the first version on:

- full OpenType Layout feature authoring UI
- hinting editor
- CFF/CFF2-specific expert tooling
- variable-font master interpolation engine
- collaborative multi-user editing
- cloud accounts
- mobile glyph editing
- full PDF authoring/editor

Keep the architecture extensible, but ship the core font workflow first.

---

# 32. Implementation priority

Build in this order:

### Phase A - project + preview
Project storage, import current Nulltongue, webfont preview, character map, font inspector.

### Phase B - Canvas editor
Viewport, path model, nodes, curves, selection, snapping, guides, metrics, measurement, undo/redo, persistence.

### Phase C - font compilation
JSON-to-font helper, style metadata, TTF/OTF/WOFF/WOFF2 outputs, validation.

### Phase D - Nerd + terminal
Nerd catalog/import/patch, terminal torture tests, collision validation.

### Phase E - language + release management
Language metadata editor, document manager, semantic version bump, manifest/checksum/release ZIP.

---

# 33. Final directive to Claude

Prefer **small understandable modules and inspectable file formats** over clever abstractions. The browser edits structured vector source; Python/fontTools handles binary font correctness; PHP coordinates storage, builds, validation, and releases.

The most important user experience is the Glyph Editor. It should feel like a real lightweight font/CAD editor: crisp splines, obvious nodes and handles, reliable snapping, accurate font-unit measurements, clear baseline/cap/x-height/cell guides, instant weight comparison, and immediate terminal preview.

Never sacrifice the Nulltongue invariants: ordinary UTF-8 underneath, clearly distinct lowercase syllabary vs uppercase logographs, fixed terminal metrics, protected higher Unicode, and Nerd Font additions that do not overwrite Nulltongue ASCII.
