# Neith — Systems Deep Dive

> The `libs/neith/` area: 312 Nx projects that make up **Neith**, Oshun's
> from-scratch ("sovereign") creative-technology stack — a runtime kernel, a
> professional DAW + plug-in hosting layer, a real-time 3D/game engine, DCC
> tools, engine-service planes (audio, GI, GPU compute, online services,
> profiling, VFX, digital humans, virtual production, LiveOps, marketplace,
> spatial), and the infra/integration libraries that wire them into the rest of
> the platform. This page is the entity-catalog view of the area.

## What this area is

"Neith" is the codename for Oshun's effort to **own its creative toolchain end
to end** rather than depend on proprietary engines and DAWs. Almost every node
here carries the word "sovereign" in its crate docs: the explicit goal is to
replace Unreal/Unity (engine), Blender/Houdini/DaVinci (DCC), Ableton/Logic/Pro
Tools (DAW), VST/AU/LV2/CLAP vendors (plug-in hosting), and even the OS layer (a
NixOS-based creative-workstation distro). The work is tracked under TODOS phases
41–46 (runtime, HAL, engine, DCC, OS, browser), 48 (domain integrations), 53
(state-of-the-art AI/procedural), and the long 132–174 sweep (audio/DAW, Forge
2D, VFX/post, platform services, CI/identity/security planes, colorist/DJ/
match-move suites, EEVEE-class raster, hair, Grease-Pencil-class 2D-in-3D,
fluids, VSE, online subsystem, profiler, GPU VFX, digital humans, virtual
production, LiveOps, marketplace, spatial runtime, engine audio, GI, GPU
compute, sculpting/NPR, and the UE/Blender final-parity families).

The area is **polyglot but Rust-dominant**. The performance-critical surface —
audio DSP, the renderer, physics, procedural generation, the OS — is Rust, laid
out as Cargo workspaces under `<entity>/crates/neith-*/`, each crate a focused
module set (`src/*.rs`). A minority of nodes are TypeScript
(`<entity>/src/ index.ts` barrels) and cover infra and orchestration concerns
where TS is the right tool: cloud/k8s config, observability, security, QA,
release, docs, training, and the six domain-integration bridges. A handful of
nodes are "dual" — a Rust Cargo workspace wrapped by an Nx `package.json` (e.g.
`@neith/ core`, `@neith/scene`, `@neith/procgen`, `@neith/particles`,
`@neith/linux`) so the cargo build participates in the Nx graph.

The nodes are not flat; they form layered sub-systems that build on each other:

- **Runtime & platform foundation** — `@neith/core` (async executor, allocators,
  events, serde, reflection), `@neith/hal` (audio/gpu/input/sensor/camera/net/
  storage abstraction), `@neith/crypto`, `@neith/net`, `@neith/transport`,
  `@neith/net-audio`, plus the TS infra libs (`@neith/cloud`, `observability`,
  `security`, `qa`, `release`, `testing`, `docs`, `training`) and
  `@neith/linux`, the OS the whole stack targets.
- **Audio / DAW ("Composer", phases 132–133)** — the real-time audio runtime and
  graph, file I/O, telemetry, MIDI, the four plug-in hosts (VST3/AU/LV2/CLAP)
  with a sandbox and validator, control surfaces, and the deep creative tools
  (mastering, restoration, pitch, notation, session view, comping, modular,
  patch-lab, advanced synthesis, live-coding, scoring, DJ, foley, ADR).
- **3D / game engine & DCC (phases 42–44, 53)** — `@neith/renderer`,
  `@neith/scene`, `@neith/particles`, `@neith/animator`, `@neith/ai-runtime`,
  `@neith/assets`, and the DCC suites `@neith/sculptor` (Blender),
  `@neith/weaver` (Houdini), `@neith/cutter` (DaVinci), plus `@neith/procgen`
  and the SOTA procedural/material crates.
- **Domain integrations (phase 48)** — `neith-integration-*` libraries that let
  existing Oshun domains (Bellona, Hathor, Isis, Maya, Sophia, Yemaya) consume
  Neith instead of their previous external engines/DCC/AI providers.

## How it fits the wider system

Neith sits at the **bottom of the creative stack**: it is the engine/runtime
that higher Oshun domains target. The relationship is expressed through the six
`neith-integration-*` libraries — each one is the adapter a specific domain
imports to drive Neith (e.g. `neith-integration-maya` migrates Maya's
Unreal-based metaverse onto the Neith engine; `neith-integration-yemaya` maps
Yemaya's creative studio onto the Sculptor/Weaver/Composer/Cutter DCC tools).
Within the area, the audio tools all stand on `@neith/audio-runtime` +
`@neith/audio-graph`; the engine/DCC tools stand on `@neith/core` and
`@neith/hal`; and the TS infra libs (cloud/observability/security/release) are
operational concerns the deployable surfaces consume. Walk the dependency edges
on any node below to see exactly who builds on it.

Since the sections above were written, the area has grown a large set of newer
sovereign Rust crate families (phases 135–172), each documented node-by-node in
the entity reference below:

- `audio-*` (phase 167) — engine-audio runtime: bus graph, sources, spatial,
  mixer, dialogue, adaptive music, voice chat, tooling, conformance.
- `broadcast` / `delivery` / `dit` / `foundry` / `hdr` / `matchmove` / `motion`
  / `shotops` / `silhouette` / `storyboard` / `subs` / `virtualprod` (phase 135)
  — film/broadcast post singles: node compositor, roto/tracking, motion
  graphics, matchmove, DIT/dailies, DCP/IMF delivery, HDR mastering,
  subtitles/dubbing, shot tracking, storyboarding, LED-volume/moco, live
  broadcast.
- `compute-*` (phase 169) — GPU-compute framework: backend abstraction, shader
  compiler, resource/dispatch/wave/memory models, ML/sim/render kernels as
  deterministic CPU references, debug layer, SDK, conformance (physical-GPU
  gates stay fail-loud).
- `dcc-*`, `engine-*`, `parity171-testing` (phases 171–172) — UE/Blender
  named-feature parity: Verse-class scripting, LWC, MegaLights, RVT, modeling,
  smart objects, choosers, pose search, state trees, motion design, enhanced
  input, GN fields/zones/tools, metaballs, NURBS, 3D text, preferences, plus the
  cross-crate validation suite.
- `dh-*` (phase 162) — MetaHuman-class digital humans: creator, skin, eyes,
  face/body rigs, flesh sim, clothing, capture animator, voice (neural TTS
  behind a fail-loud seam), retarget, ethics/consent, SDK, testing.
- `forge-*` — creative-app primitives (whiteboard, fonts, generative-imaging
  workflow, icons, interactive motion, photo catalog, publishing) as large
  single-file model+operations crates.
- `gi-*` (phase 168) — dynamic global illumination: core abstraction, SDFGI,
  voxel GI, probes/DDGI, Lumen-class tracing, shadows, lightmapper, AO,
  volumetrics, emissive, sky, conformance.
- `gpen-*` (phase 156) — Grease-Pencil-class 2D-in-3D suite: data model, tools,
  animation, modifiers, line art, shading, rigging, VR drawing, storyboard,
  testing.
- `hair-*` (phase 155) — curves-based hair: data model, grooming, guides, nodes,
  simulation, shading, rendering, presets, transfer, validation.
- `liveops-*` (phase 164) — monetisation/liveops: IAP, ads, analytics, remote
  config, experiments, economy, cloud save, attribution, CRM, support,
  compliance, portal, conformance.
- `market-*` (phase 165) — creator marketplace: catalog, creator onboarding,
  licensing, commerce, delivery, discovery, reviews, moderation, buyer portal,
  seller analytics, SDK, conformance.
- `npr-*` (phase 170) — non-photoreal rendering: Freestyle-class lines, cel/toon
  shading, inking/hatching.
- `oss-*` (phase 159) — Online Subsystem and replication: abstraction, identity,
  matchmaking, sessions, Iris-class replication, RPC, prediction, transport,
  voice, presence, replay, pixel streaming, anti-cheat, observability, testing.
- `profiler-*` (phase 160) — frame profiler and diagnostics: capture, timing,
  GPU debugger, memory, net, stat HUD, sampling, shader, physics, audio,
  asset/cook, UI models, crash analysis, testing.
- `sculpt-*` (phase 170) — ZBrush/Blender-class sculpting: core, topology,
  layers, brushes, face sets, masking, polypaint, retopo, export, testing.
- `sim-*` (phase 157) — Mantaflow/Houdini-class offline simulation: core,
  liquid, gas, MPM, particles, cloth, rigid, ocean, surface meshing, forces,
  reference rendering, game baking, farm planning, validation.
- `spatial-*` (phase 166) — MR/visionOS-class spatial runtime: core scene
  understanding, volumes, input, avatars, render, physics, audio, SDK,
  collaborative anchors, OS shell, conformance.
- `vfx-*` (phase 161) — Niagara-class GPU-VFX authoring: asset model, spawn,
  attributes, modules, renderers, sim stages, data interfaces, editor model,
  perf/LOD, preset library, testing.
- `vp-*` (phase 163) — on-set virtual production: core, render cluster, LED
  wall, camera tracking, ICVFX frustum, colour, scene pipeline, MR keying,
  operator control, record, broadcast studio, editorial handoff, testing.
- `vse-*` (phase 158) — DCC-embedded video sequence editor: timeline core,
  ingest, transitions, effects, audio, playback, render, review, conform,
  storyboard, testing.

Across all of these, each family's conformance/testing crate exercises the real
sibling crates, and genuinely external boundaries (GPU drivers, ffmpeg, native
Opus, neural models, tracker/encoder hardware) are represented as fail-loud
seams rather than fabricated results.

## Entity reference

### @neith/core

The sovereign **runtime kernel** (`core/crates/`): a from-scratch async executor
(`neith-runtime` — work-stealing scheduler, fibers, mpmc/mpsc/broadcast
channels, timers, backpressure), purpose-built allocators (`neith-alloc` —
arena/slab/buddy/tlsf/mmap/huge-page), plus `neith-events`, `neith-serde`,
`neith-reflect`, and `neith-log`. This is the foundation the rest of Neith's
Rust stands on; substantial and real.

### @neith/hal

The **hardware abstraction layer** (`hal/crates/`): seven crates —
`neith-audio-hal` (device enum + PCM via `cpal`: ALSA/PulseAudio/PipeWire/
CoreAudio), `neith-gpu`, `neith-input`, `neith-sensor`, `neith-camera`,
`neith-net-hal`, and `neith-storage` (virtual paths, ZIP, S3, keystore). It
gives the engine and tools one portable surface over real OS backends.

### @neith/crypto

Sovereign cryptography (`crypto/crates/`): `neith-sym` (full AES-256-GCM with
real S-box/MixColumns + ChaCha20-Poly1305), `neith-asym` (Ed25519/X25519 field
arithmetic), `neith-hash` (SHA-2/BLAKE3/HMAC/Merkle/Argon2id/HKDF), `neith-rand`
(ChaCha20 CSPRNG, RDRAND, fork-safe), and `neith-tls` (TLS 1.3
session/handshake/cert validation). Domain-specific implementations, not
wrappers.

### @neith/net

General networking (`net/crates/`): `neith-http` (HTTP/1.1/2/3 codec, pooling,
caching), `neith-transport` (reliable UDP with congestion control + NAT
traversal), `neith-webrtc` (DataChannel/ICE/SDP/DTLS/SRTP/SCTP), and
`neith-game-net` (authoritative server, prediction/reconciliation, snapshot
interpolation, lag compensation, anti-cheat).

### @neith/transport

The audio **transport, clock, and synchronization** core (phase 132.11,
`transport/crates/neith-transport`): the project-wide transport state machine
plus chase-lock / drift-correction infrastructure every audio-producing surface
shares. Distinct from `@neith/net`'s `neith-transport` (which is UDP).

### @neith/net-audio

Network-audio crate (`net-audio/crates/neith-net-audio`, ~27.6K LOC): the
streaming-audio-over-network layer for the DAW/engine. Substantial single crate.

### @neith/audio-runtime

The **sovereign cross-platform audio HAL** (phase 132.1, ~74K LOC): defines the
`AudioDriver`/`AudioStream` traits every backend (CoreAudio, ASIO, WASAPI, JACK,
PipeWire, ALSA, AAudio, OpenSL ES) implements. The driver-level foundation the
real-time graph runs its callback on.

### @neith/audio-graph

The **real-time audio graph** (phase 132.2, ~21K LOC): hosts the driver callback
and routes audio/MIDI/CV between tracks, buses, sends, plugins, and outputs.
Rich scheduler subtree (`scheduler/` — SPSC, sub-block, RT-priority/asserts,
parallel exec, denormal handling, watchdog, CPU meter) plus PDC (plugin delay
compensation), sidechain, feedback, and multichannel modules.

### @neith/audio-fileio

**Sovereign audio file I/O** (phase 132.12, ~80K LOC, 212 files): one reader +
writer per container (WAV/AIFF/FLAC/etc.) feeding the audio graph and receiving
offline bounces from `@neith/transport`, behind a uniform `FileIoError` funnel
and shared `sample` primitives. One of the largest crates in the area.

### @neith/audio-telemetry

Audio **metering / loudness / analysis** (phase 132.14): per-block/per-frame
Peak/RMS/VU/PPM/K-meters plus EBU R128 / ATSC A/85 / ITU-R BS.1770-5 loudness —
the analysers every audio surface in Oshun consumes.

### @neith/midi-io

**Cross-platform MIDI I/O** (phase 132.8): one `MidiBackend` trait with a
per-platform implementation, the foundational MIDI surface Composer, Euterpe,
Uzume, dialogue, and spatial all depend on (~23K LOC).

### @neith/vst3-host

Sovereign **VST3 plug-in host** (phase 132.3, ~24K LOC, 77 files): implements
Steinberg's VST3 SDK host interfaces from Rust — discovery/loading, processing,
component/edit-controller model. Real host stack.

### @neith/au-host

Sovereign **Audio Unit (AU) host** (phase 132.4): hosts both AUv2 (the legacy
`AudioComponentFindNext` component model) and AUv3 (`NSExtension`) plug-ins.
macOS/iOS-only by design — other platforms get a structured `NotSupported` error
rather than a link failure (an honest fail-loud seam).

### neith-clap-host

Sovereign **CLAP plug-in host** (phase 132.6, ~34K LOC): discovers `.clap`
bundles by walking the platform search path, dlopens them, resolves the
`clap_entry` symbol, and hosts modern CLAP plug-ins. Note the bare project name
`neith-clap-host` (tags `scope:neith`, `lang:rust`).

### @neith/lv2-host

Sovereign **LV2 plug-in host** (phase 132.5): discovers `.lv2/` bundles via
`LV2_PATH`, parses the Turtle (`manifest.ttl`) RDF, and loads the bundle's
shared libraries. Real bundle/RDF parsing, not a stub.

### neith-plugin-sandbox

**Out-of-process plug-in sandbox** (phase 132.7, ~15K LOC): isolates third-party
VST3/AU/LV2/CLAP code from the host so a crashing/hanging/malicious plug-in
can't take down the DAW. Bare project name `neith-plugin-sandbox`.

### @neith/plugin-validator

**Plug-in validator** (phase 132.13, ~840 LOC, 5 files — the smallest host-layer
crate): a uniform validation framework that runs against any plug-in the host
can load (across all four host crates). Real but intentionally compact.

### @neith/controllers

**Hardware control-surface integration** (phase 132.10, ~35K LOC): Mackie
Control Universal, HUI, EuCon, OSC, custom Lua/WASM scripts, and generic HID —
each protocol a pure-Rust codec + state machine in its own module.

### @neith/composer

The **DAW core** as a 5-crate workspace (`composer/crates/`): `neith-daw-core`
(timeline/recording/audio-ops/analysis), `neith-mixer` (channels/metering/
automation/routing), `neith-midi` (piano-roll/CC-routing/theory), `neith-synth`
(sampler/subtractive/FM/wavetable/granular), and `neith-spatial-audio`
(panner/environment/game-audio). The Ardour-class assembly point for the audio
tools.

### @neith/mastering

**Ozone-class mastering suite + Neutron-class mix assistant** (phase 133.5, ~19K
LOC): mastering modules, an assistant/reference engine, and stem-focus /
diffusion-mastering SOTA work, each task as a focused module.

### @neith/restoration

**iZotope-RX-class audio restoration** (phase 133.3, ~42K LOC): spectral repair
and the dialogue/audio restoration toolkit. Large, substantial single crate.

### @neith/pitch

**Melodyne-class polyphonic pitch & time editing** (phase 133.4, ~13K LOC):
polyphonic note detection plus formant-preserving pitch/time manipulation.

### @neith/notation

**Dorico-class music-notation engraving** (phase 133.1, ~51K LOC, 65 files):
provides the hierarchical score model and engraving foundation — the layout,
beaming, and music-symbol rendering on which the rest of the Neith notation
stack builds. One of the larger creative crates.

### @neith/session-view

**Ableton-class clip launcher / Session View** (phase 133.2, ~18K LOC): the
non-linear clip-grid performance surface that complements the DAW's linear
arrangement.

### @neith/comping

**Comping, track stacks, folder tracks** (phase 133.14): take-folder data model
with parent clip, ordered takes, active-take pointer, and per-take metadata —
the session-management tools for multi-take recording (~8K LOC).

### @neith/modular

**VCV-Rack-class modular synth environment** (phase 133.6, ~42K LOC, single
crate): a sovereign modular-synthesis patching environment for the Composer DAW.

### @neith/patch-lab

**Max/MSP / Pure-Data-class visual patching** (phase 133.7, ~18K LOC): a
sovereign visual dataflow patching environment.

### @neith/synth-advanced

**Advanced-synthesis library** (phase 133.9, ~17K LOC): additive, spectral,
modal, physical-modeling, neural, scanned, waveguide, and vector synthesis —
each engine its own module behind a shared `SynthEngine` trait.

### @neith/live-code

**Embedded live-coding runtime** (phase 133.8, ~20K LOC): a small scripting
language (lexer/parser/runtime) whose source is hot-reloaded against a running
audio session — TidalCycles/Sonic-Pi-class.

### @neith/scoring

**Scoring-to-picture toolkit** (phase 133.10, ~12K LOC): frame-accurate
scrubbing, spotting notes, streamers/punches, and tempo/hit-point maps for
film/TV/game composers — beyond a generic DAW+video-sync.

### @neith/dj

**Sovereign DJ deck toolkit** (phase 133.12, ~24K LOC): Serato/Traktor/
Rekordbox-class — 2/4-deck transport, beat-grid + key detection, master tempo,
hot cues, loops, slicer, real-time stem separation, FX rack, sampler, automix,
and CloudDirectPlay streaming.

### @neith/foley

**Generative Foley / video-conditioned SFX** (phase 133.16, ~9.6K LOC): maps
text prompts and video frames to typed SFX templates and synthesises real PCM
via additive+noise+envelope DSP, then refines with a published DDIM sampler.
Deterministic, no external neural model — an honest documented approximation.

### @neith/adr-foley

**ADR + Foley post-production toolkit** (phase 133.11, ~10K LOC): cue lists,
streamers/beeps, take management, looping playback, VocAlign-class
auto-alignment, EQ/reverb match, foley library, mic-perspective routing, and
walla — the data + operations a post sound team needs.

### @neith/realtime-assist

**Real-time AI mixing/mastering collaboration** (phase 133.15, ~8.3K LOC): an
on-device assistant that watches a session live and emits structured suggestions
for balance, EQ, gain-staging, panning, masking, and chain-building.

### @neith/sample-content

**Sample-library tooling** (phase 133.13, ~39K LOC): recording session specs and
the sovereign sample-library authoring/management surface.

### @neith/sound-propagation

**Geometry-aware acoustic propagation**
(`sound-propagation/crates/ neith-acoustics`, single ~1.8K-LOC crate):
octave-band sound energy through scene geometry, acoustic materials, probe
grids, diffraction edges, and portals — deterministic so cook servers/CI
reproduce impulse responses byte-for-byte.

### @neith/renderer

The **real-time 3D engine renderer** (phase 42, ~96K LOC, 193 files, 16 crates —
the largest entity): `neith-render-graph` (frame graph), `neith-pbr`,
`neith-material-graph`, `neith-gpu-driven`, `neith-virt-geom` (Nanite-class
clustered geometry), `neith-gi`, `neith-shadows`, `neith-lighting`,
`neith-atmosphere` (Bruneton sky), `neith-postfx`, `neith-gaussian-splatting`
(3DGS), plus `neith-ecs`, `neith-physics`, `neith-animation`, `neith-audio`, and
`neith-scripting`. A genuine engine, not a façade.

### @neith/scene

**Scene composition** (phase 43.3, `scene/crates/`): `neith-scene-graph`
(hierarchical node graph), `neith-level-stream` (streaming zones, distance-based
load/unload), and `neith-world` (grid-based world partitioning + collaboration).
Smaller (~4K LOC) but real.

### @neith/particles

**GPU particle system + VFX graph** (phase 43.4, `particles/crates/`):
`neith-particle-core` (`#[repr(C)]` CPU-side sim layout for GPU staging-buffer
upload) and `neith-vfx-graph` (node-based VFX editor/compiler).

### @neith/animator

**Animation authoring** (phase, `animator/crates/`, ~23K LOC): `neith-motion`
(pose-search DB for motion matching), `neith-mocap` (import/solving/retarget/
editing), `neith-rig` (armature/constraints/control-rig), `neith-facial`
(eye-jaw/lip-sync/facial-rig), and `neith-timeline` (curve editor/dope sheet).

### @neith/ai-runtime

**Game-AI + ML runtime** (phase 43.1 + 53.2, ~51K LOC, 8 crates):
`neith- navigation` (Recast-style NavMesh, A*/HPA*/flow-field),
`neith-behavior-tree`, `neith-ai-fsm` (HSM/pushdown), `neith-perception`
(sight/hearing/touch/smell), `neith-crowd` (ORCA + flow fields),
`neith-ml-inference` (ONNX runtime, LRU model cache, quantization), `neith-npc`
(personality/backstory/goals), and `neith-llm` (a normalized
OpenAI/Anthropic/Ollama integration layer).

### @neith/assets

**Asset pipeline** (phase 43.2, `assets/crates/`): `neith-asset-format` (the
`.nba` binary container — header/chunks/dependencies/versioning), plus
`neith-asset-import`, `neith-asset-proc`, `neith-asset-stream`, and
`neith-asset-registry`.

### @neith/sculptor

**Blender-class DCC** (phase 44.1, `sculptor/crates/`): `neith-mesh-edit`
(selection/editing), `neith-sculpt` (brushes, dyntopo, multires, masking),
`neith-uv` (LSCM/ABF unwrap, UDIM), `neith-tex-paint` (channels/layers/
projection paint/baking), and `neith-sculptor-render` (viewport + path tracer +
render passes).

### @neith/weaver

**Houdini-class procedural DCC** (`weaver/crates/`, ~54K LOC):
`neith-node-graph` (execution graph), `neith-geo-nodes`
(attributes/distribution/primitives), `neith-terrain` (biome-aware generation,
GIS import, GPU sculpting), `neith-building` (procedural buildings/cities), and
`neith-copernicus` (GPU/WebGPU-compute texture synthesis with CPU parity).

### @neith/cutter

**DaVinci-Resolve-class video editor** (`cutter/crates/`, ~48K LOC):
`neith-video-timeline` (multi-track NLE — clips, ripple/roll, snapping,
multicam, nested sequences, proxy), `neith-color-grade`, `neith-vfx`, and
`neith-export`.

### @neith/procgen

**Procedural-generation systems** (phase 53, `procgen/crates/`, ~52K LOC, 12
crates): a differentiable-procgen substrate (`neith-diff-procgen`), inverse
modeling (`neith-inverse-procgen`, differential evolution), `neith-jfa`,
`neith-nca` (neural cellular automata),
`neith-neural-flora`/`neith-neuro-facade` (neuro-symbolic L-systems/facades),
`neith-physarum`, `neith-scene-agent` (LLM-or-deterministic scene programs),
`neith-terrain-ml`, `neith-texture-synth` (Heitz-Neyret histogram-preserving),
`neith-tiling` (Wang tiles), and `neith-wave-noise` (Guehl 2025 wave-noise).
Real named algorithms, CPU parity.

### @neith/fabric-gen

**Procedural fabric generation** (`fabric-gen/crates/neith-fabric`, single ~2K
crate): authors weaving drafts, generates yarn-level geometry with sliding/
flyaway irregularity, evaluates an anisotropic fiber BSDF, bakes PBR maps, and
estimates drape. Deterministic textile-prompt → weave-recipe.

### @neith/pbr-material-synth

**Physically-based material synthesis**
(`pbr-material-synth/crates/ neith-mat-phys`, single ~1.8K crate): turns
measured/physical material properties (spectral IORs, absorption, scattering,
microstructure, weathering, layered stacks) into renderer-facing PBR parameters
— deterministic and serializable.

### @neith/topology-opt

**SIMP topology optimization** (`topology-opt/crates/neith-topopt`, single ~2.3K
crate): 8-node hexahedral grid, sparse stiffness assembly, conjugate-gradient
displacement solves, sensitivity filtering, and optimality-criteria density
updates for procedural structural geometry. Includes a GPU dispatch-plan type.

### @neith/forge-core

**Forge 2D shared foundation** (`forge-core/crates/forge-doc-graph`): currently
the hierarchical Forge document node graph (134.1.1.1) — `doc.rs`, `layer.rs`,
`transform.rs`. The package description scopes Forge to "document graph, canvas,
color, and plugin host," but the **present, implemented crate is the document
graph** (~4K LOC); the broader canvas/color/plugin-host pieces are not yet in
this entity.

### @neith/ui

**UI toolkit** (`ui/crates/`, ~14.6K LOC): `neith-layout` (flexbox + CSS grid +
positioning + virtualized lists), `neith-render2d` (paths/gradients/blend/
compositing), `neith-text` (shaping/glyph cache/rich text/IME), `neith-widgets`
(Button…DataGrid…Modal), `neith-theme` (design tokens), and `neith-animation`
(springs/keyframes/transitions). A from-scratch retained-mode UI stack.

### @neith/linux

**Neith Linux** (phase 45, `linux/crates/`, ~78K LOC, 17 crates — a NixOS-based
creative-workstation OS): the Wayland compositor (`neith-shell`), package
manager (`neith-pkg`/`neith-pkg-manager`/`neith-overlay-manager`), A/B atomic
updater (`neith-update-agent`), kernel builder + `neith-workload-tuner`, and
full `neith-audio` (PipeWire), `neith-graphics` (DRM/KMS), `neith-network`,
`neith-storage` (Btrfs/LUKS), `neith-security` (SELinux/AppArmor/TPM),
`neith-services` (systemd), `neith-settings`, `neith-installer`, and
`neith-creative` subsystems. The OS the whole stack targets.

### @neith/cloud

**Cloud-infrastructure config** (TS, ~23K LOC, 66 files): dependency-free
factory builders for `compute` (k8s deployments/autoscaling/GPU workloads),
`gpu` (node pools, MIG, time-slicing), `storage` (PVCs, backup/DR, lifecycle),
and `network` (VPC, CDN, WAF, DDoS). Tagged `layer:infra`.

### @neith/observability

**Observability infra** (TS, ~17K LOC): `metrics`, `logging`, and `tracing`
(distributed) building blocks for the deployable Neith surfaces. Tagged
`layer:infra`.

### @neith/security

**Security infra** (TS, ~13.7K LOC): `iam` (identity & access), `secrets`
(secret management), and `compliance` modules. Tagged `layer:infra`.

### @neith/qa

**Quality-assurance infra** (TS, ~22.3K LOC): `code-quality` analysis and
`doc-quality` tooling. Tagged `layer:infra`.

### @neith/release

**Release & distribution** (TS, ~16.7K LOC): `pipeline`, `distribution`,
`performance`, and `platform/*` publishers for thirteen targets (Linux, Windows,
macOS, iOS, Android, Steam, Epic, Xbox, PlayStation, Nintendo, Meta Quest, web)
plus an enterprise software-catalog publisher (ServiceNow/Coupa/SAP-Ariba). Has
a 163-line README.

### @neith/testing

**Test infrastructure** (TS, ~28.7K LOC — the largest TS entity): `unit`,
`integration`, `e2e`, and `performance` utilities spanning TypeScript/Vitest,
Rust/cargo-nextest, and C++/GTest/Catch2, exported as namespaces from the
barrel.

### @neith/docs

**Documentation system** (TS, ~15K LOC): `developer`, `user`, and `api` doc
modules exported as namespaces from `@neith/docs`. Tagged `layer:docs`.

### @neith/training

**Training & education** (TS, ~11.4K LOC): developer courses, user onboarding,
certifications, and community resources for the Neith engine. Tagged
`layer:training`.

### neith-integration-bellona

**Bellona (Build & Engine) ↔ Neith** bridge (TS, ~6.8K LOC): native build tools,
deployment automation, and observability — `build-system/` and
`deployment-system/` modules. Bare project name; tags `scope:neith`,
`scope:bellona`, `type:integration`.

### neith-integration-hathor

**Hathor (Worldbuilding) ↔ Neith** bridge (TS, ~9.4K LOC): world simulation,
procedural generation, and content-creation tooling tied into the Neith engine
and Nous AI (`world-simulation/`, `content-creation/`).

### neith-integration-isis

**Isis (Generative AI Factory) ↔ Nous** bridge (TS, ~6.2K LOC): replaces
external AI-provider APIs with the in-house Nous LLM — `nous-streaming.ts` (with
a spec), `ai-replacement/`, and `generation-pipeline/`.

### neith-integration-maya

**Maya (game engine / metaverse) ↔ Neith** bridge (TS, ~14.6K LOC): engine
replacement (Unreal → Neith migration, 48.1.1) and metaverse-platform hosting
(VR OS, avatars, economy, AI NPCs, 48.1.2) — `engine-replacement/`,
`metaverse-platform/`.

### neith-integration-sophia

**Sophia (Knowledge) ↔ Neith** bridge (TS, ~5.5K LOC): `knowledge-system/` and
`research-tools/` modules connecting Sophia's knowledge surface to Neith.

### neith-integration-yemaya

**Yemaya (Creative Studio) ↔ Neith DCC** bridge (TS, ~5.6K LOC): maps Yemaya
onto the Neith DCC tools — Sculptor (Blender), Weaver (Houdini), Composer
(Ardour), Cutter (DaVinci) — plus a unified creative pipeline (project format,
VCS, render farm, review, asset library, Nous-assisted creation). `dcc-tools/`,
`creative-pipeline/`.

### @neith/audio-accessibility

Game-audio accessibility runtime (Rust, `libs/neith/audio-accessibility`, phase
167.12): `mix` (mono down-mix + L/R balance), `speech` (dialogue-clarity and
hearing-aid EQ), `haptics` sound substitution, timed `captions`, and a
`protection` volume-ceiling hearing protector — targeting the Xbox/PlayStation
accessibility guidelines for engine audio.

### @neith/audio-bus-graph

Runtime audio routing plane (Rust, `libs/neith/audio-bus-graph`, phase 167.1):
directed source→bus→group→output `routing` with glitch-free runtime `mutation`,
sample-accurate event `schedule`, mix `snapshot`s, per-bus `resample`, and
`hotreload` of graph assets. Distinct from the phase-132 DAW graph
`@neith/audio-graph` — this is the graph a shipped game renders every audio
callback.

### @neith/audio-conformance

Cross-crate conformance suite for the phase-167 engine-audio stack
(`libs/neith/audio-conformance`) — a testing crate, not a runtime feature. Real
gates (`voice_count_stress`, `latency_p99`, `atmos_render_determinism`,
`loudness_compliance`) exercise the sibling crates end-to-end and return
`GateResult`s. The `dogfood` gate binds the real Phase-42 audio engine and
Phase-27 Project Obsidian roots, renders a Phase-42 procedural footstep through
the phase-167 HRTF path, and validates the franchise audio contract. The
`external` module retains fail-loud seams for the listening-panel ABX and
live-device 24-hour soak.

### @neith/audio-dialogue

Game dialogue system (Rust, `libs/neith/audio-dialogue`, phase 167.6): line
`database` with voice banks and per-locale fallback, condition-driven
`selection` with bark cooldowns, branching `conversation` flow, phoneme/viseme
`lipsync` export, and `radio`/walkie voice FX — the Wwise-dialogue-event /
FMOD-programmer-sound layer.

### @neith/audio-environment

Acoustics and environmental FX (Rust, `libs/neith/audio-environment`, phase
167.4): `reverb` (partitioned convolution + FDN/Schroeder), `occlusion` ray
casting over `geom` primitives, morphing reverb `zones`, `ambience` beds, and
baked/ray-traced `acoustics` probe fields — Steam Audio / Project
Acoustics-class features rebuilt from first principles.

### @neith/audio-mix

Master-mix plane above the bus graph (Rust, `libs/neith/audio-mix`, phase
167.5): dB-domain `snapshot` interpolation, sidechain `ducking`, a per-bus
`dsp_chain` (RBJ EQ / compressor / lookahead limiter / saturator), a `truepeak`
4x-oversampled ISP limiter, and ITU-R BS.1770-4 `loudness` metering with EBU
R128 `normalize` — all f64 DSP implemented in-crate with no external audio
dependencies.

### @neith/audio-music

Adaptive/interactive music runtime (Rust, `libs/neith/audio-music`, phase
167.7): vertical/horizontal `layers` with tension coupling, bar/beat-quantised
`transitions` and stingers, a `mood`-graph state machine, a tempo/key
`transport` with Ableton-Link-style clock sync, and a `euterpe` generative-stems
hook.

### @neith/audio-profiler

Audio instrumentation plane (Rust, `libs/neith/audio-profiler`, phase 167.10):
`voices` count and stem accounting, per-bus DSP `budget`s, underrun/asset-hitch
`events` logs, a mix-graph `flamegraph`, and trigger-to-ear `latency` metering —
Wwise/FMOD-Profiler-class diagnostics, separate from the engine-wide profiler-\*
family.

### @neith/audio-source

Voice-generator library for the bus graph (Rust, `libs/neith/audio-source`,
phase 167.2): every generator implements the `AudioSource` trait — `sample` and
`stream` voices, band-limited `oscillator`s, `physical` Karplus-Strong/modal
models, `granular` clouds, random/switch/sequence/layer `container`s, and WSOLA
time-stretch.

### @neith/audio-spatial

3D audio spatialisation (Rust, `libs/neith/audio-spatial`, phase 167.3):
distance `attenuation` curves, directional emitter `cone`s, `doppler`,
spherical-head `hrtf` binaural with HRIR interpolation, higher-order `ambisonic`
decode, and `atmos` bed+object rendering with VBAP `panning` to 5.1 through
9.1.6 layouts.

### @neith/audio-synth

Procedural SFX synthesis (Rust, `libs/neith/audio-synth`, phase 167.8): `modal`
impact/breakage mode banks, material/weight `footstep`s, layered `weapon` shots,
additive+granular vehicle `engine`s, swept-noise `wind`, bubble-model `water`,
and source-filter `creature` vocals — every effect computed from a physical or
signal model rather than a sample.

### @neith/audio-tooling

Sound-designer authoring plane (Rust, `libs/neith/audio-tooling`, phase 167.11):
`events` designer with state/switch/RTPC editing, a MetaSounds-class timeline
action `graph`, soundbank `banks` packaging with offline bake, a waveform asset
`browser`, a `localization` coverage matrix, and a live-connect `session`
command model.

### @neith/audio-voice

Multiplayer voice-chat and microphone pipeline (Rust, `libs/neith/audio-voice`,
phase 167.9): 20 ms Opus-frame `codec` packetisation with jitter buffer and loss
concealment, spectral-subtraction `denoise`, NLMS `aec`, envelope `agc`, a WSOLA
voice `changer`, `proximity`/team `channels` routing, and `moderation` hooks.
The Opus bitstream itself lives in the phase-159 OSS stack.

### @neith/broadcast

Live-broadcast plane (Rust, `libs/neith/broadcast`, phase 135.12): a 36-module
crate covering the `switcher` (buses, transitions, `stinger`, keyers, PiP),
`multiviewer`, `lower_third`/ticker/scoreboard graphics, and captioning plus
loudness. The `sdi`/`ndi`/`smpte2110`/`blackmagic` modules are typed
protocol/control models, not hardware driver bindings.

### @neith/compute-abstraction

Front door of the phase-169 GPU-compute framework (Rust,
`libs/neith/compute-abstraction`): a single `backend` API shaped over
Vulkan/Metal/D3D12/WebGPU/CUDA/HIP/SYCL with `capability` flags, `device`
enumeration and a best-device heuristic, `multi_gpu` peer topology, and a real
deterministic `cpu_backend` reference. Native APIs attach through a versioned,
backend-bound executable-provider protocol. Manifest discovery, probe,
enumeration and dispatch are real; nonce/identity, device metadata, artifact
format, dispatch limits, read-only buffers, output shape, and timing are
validated fail closed before provider output enters the runtime.

### @neith/compute-conformance

Khronos-CTS-style conformance suite for the compute stack
(`libs/neith/compute-conformance`): bit-reproducible `correctness` checks
against the CPU reference backend, a suballocator `leak_burnin`, a
`determinism_regression` sweep, and typed fail-closed evidence graders plus the
`compute-validate` operator CLI for CUDA/HIP parity, browser WebGPU, 24-hour
soak, multi-GPU scaling, dogfood, and console gates. Synthetic evidence can
exercise decisions but can never certify a release.

### @neith/compute-debug

GPU-compute debug and validation layer (Rust, `libs/neith/compute-debug`, phase
169.10): resource-binding `validation`, a happens-before `race` detector,
`bounds` and `nan` checkers, a shader assert/printf `shader_debug` runtime, and
a shadow-memory `sanitizer` — ASan/TSan-style tooling operating on recorded
compute state.

### @neith/compute-dispatch

Dispatch model of the compute framework (Rust, `libs/neith/compute-dispatch`,
phase 169.4): direct/indirect/mesh/RT `dispatch` with validation, async-compute
and copy `queue` topology, pipeline `barrier`s with hazard classification,
fence/event `sync`, and dispatch `batching` — the command-buffer/queue/barrier
surface, modelled and tested in-crate rather than driver-bound.

### @neith/compute-lang

Sovereign shader compiler (Rust, `libs/neith/compute-lang`, phase 169.2): an
SSA-form `ir`, recursive-descent `lexer`/`parser` for a shared WGSL/HLSL/GLSL
compute grammar, real `opt` passes (constant folding, DCE, CSE, loop unrolling),
pipeline `reflect`ion, five text `targets` plus MSL/Slang transpile, and an AMD
ISA occupancy diagnoser — pure std and fully deterministic.

### @neith/compute-memory

GPU memory model and allocators (Rust, `libs/neith/compute-memory`, phase
169.6): memory `heap`s with budget alarm, a fence-tracked `staging` ring,
`paged` virtual memory with LRU residency, `bump` and size-class `pool`
allocators, and a VMA-class free-list `suballoc`ator with coalescing and
defragmentation — real placement algorithms over byte offsets.

### @neith/compute-ml

ML inference kernels for the compute stack (Rust, `libs/neith/compute-ml`, phase
169.7) — deterministic CPU reference implementations, not GPU execution: an
n-dim strided `tensor` primitive, tiled `gemm` + Conv2D (im2col), fused
`activations` (ReLU/GELU/SiLU), LayerNorm/RMSNorm `norm`, flash-style
`attention`, `quant`isation, and a `gguf` reader, each tested against
known-correct values.

### @neith/compute-render

Compute-shader building blocks of a GPU-driven renderer (Rust,
`libs/neith/compute-render`, phase 169.9), implemented as CPU-verified
per-element math: frustum `culling` + `hiz` occlusion pyramid, meshlet
`geometry` cone culling, clustered `lights` froxel lists, bone-palette
`skinning`, `particles`, `postprocess` kernels (Karis bloom, TAA resolve), and a
`swrast` software rasteriser.

### @neith/compute-resources

Resource model of the compute framework (Rust, `libs/neith/compute-resources`,
phase 169.3): storage/structured/append/counter `buffer`s, 1D/2D/3D/array/cube
`texture`s with correct mip and subresource indexing, `sampler`s, a bindless
`descriptor` heap, and spec-exact std140/std430 `layout` arithmetic — the
Vulkan/D3D12/Metal/WebGPU resource surface as tested layout rules.

### @neith/compute-sdk

Developer SDK for the compute framework (Rust, `libs/neith/compute-sdk`, phase
169.11): `bindings` signature emission for C/C++/Rust/Swift/Python/TS, a
kernel-authoring `dsl`, runnable `examples` (matmul/raymarch/fluid/FFT) with
reference outputs, a `bench` harness computing real mean/median/percentile/CoV
statistics with IQR outlier detection, plus `stress`, `compat`, and `docs`
tooling.

### @neith/compute-sim

Simulation kernels for the compute stack (Rust, `libs/neith/compute-sim`, phase
169.8) — deterministic f64 CPU reference implementations that GPU backends are
diffed against: direct + Barnes-Hut `nbody`, SPH/PIC/FLIP/APIC `particles`
transfer, PCG/multigrid `pressure` Poisson solvers, `xpbd` constraint
projection, radix-2 Cooley-Tukey `fft`, plus `scan`/`sort`/`bvh` primitives.

### @neith/compute-wave

Wave/subgroup operations (Rust, `libs/neith/compute-wave`, phase 169.5) — a
deterministic CPU model of the SIMD lane group (warp/wavefront/subgroup): `vote`
(all/any/ballot), `broadcast`, `reduce`, inclusive/exclusive `scan`,
`shuffle`/swizzle, and `coopmat` cooperative-matrix multiply-accumulate over
FP8/FP16/BF16/INT8 tiles — the HLSL SM6 / CUDA-warp intrinsic surface as a
testable model.

### @neith/dcc-bsurfaces

Retopology and quad-remesh toolbox (Rust, `libs/neith/dcc-bsurfaces`, phase
171.24): grease-pencil-stroke `bsurfaces` surface fill, a quad-flow `retopo`
brush with symmetry and shrinkwrap, auto-quad `remesh`, `curvature` edge-loop
extraction, hole `patch`ing, and high-to-low displacement/normal `bake` — the
sovereign BSurfaces + QuadriFlow + bake equivalent, integrating the phase-170
sculpt crates.

### @neith/dcc-data

Data-block linking and library overrides (Rust, `libs/neith/dcc-data`, phase
171.25): `library` link/append of external data-blocks, `overrides` that edit
linked data without breaking the link (scope, propagation on re-link, per-
property and animation overrides), an orphan `cleaner` with fake-user retention,
and an outliner override `diff` view — Blender's linking system as a sovereign
model.

### @neith/dcc-freestyle-extensions

Deep NPR line-render controls (Rust, `libs/neith/dcc-freestyle-extensions`,
phase 171.26) extending the phase-170 Freestyle core: a multi `lineset` manager,
`edgetype` include/exclude matrix, parametric line `style` expressions along the
stroke, colour/alpha/thickness + geometry `modifiers` stacks, `svg` export, a
compositor `bridge`, and temporal stroke `coherence`.

### @neith/dcc-gn-fields

Geometry-Nodes fields system (Rust, `libs/neith/dcc-gn-fields`, phase 171.20): a
lazy, domain-dependent `field` evaluator with position/normal/attribute inputs,
noise/voronoi generators and math operators, `capture`-attribute persistence
with accumulate/scan/sort, cross-domain `sample`, a viewport `visualize`r, and a
`gpu` compilation fastpath — Blender's GN fields as a sovereign evaluator.

### @neith/dcc-gn-repeatzones

Geometry-Nodes repeat and for-each zones (Rust, `libs/neith/dcc-gn-repeatzones`,
phase 171.22): a `repeat` zone with `accumulator` sockets, break conditions,
index/total exposure and nesting, an order-independent parallel-safe `foreach`
element zone, and a `gpu` unroll fastpath for affine recurrences.

### @neith/dcc-gn-simzones

Geometry-Nodes simulation zones (Rust, `libs/neith/dcc-gn-simzones`, phase
171.21): a `zone` input/output pair carrying per-frame `state` with substepping
and reset/retime, RAM+disk `cache`/bake with upstream hash invalidation, a
deterministic per-zone `rng`, `nested` zones with a profiler, and built-in
`blocks` (advection, boids, PBD cloth, soft body).

### @neith/dcc-gn-tools

Geometry-node asset tools (Rust, `libs/neith/dcc-gn-tools`, phase 171.23): node
groups exposed as operators — `tool` + `inputs` parameter-UI descriptors,
`shelf` install and drag-drop apply, `mode` auto-switch with undo integration,
and a `publish` path (presets, share, marketplace certification checks) —
Blender 4.0+ node-group tools as a sovereign model.

### @neith/dcc-metaballs

Metaball primitive (Rust, `libs/neith/dcc-metaballs`, phase 171.16):
ball/tube/plane/cube/ellipsoid `element`s with stiffness/radius and negative
(subtractive) energy, a summed implicit `field` with iso threshold,
`marching`-tetrahedra mesh conversion, per-object `resolution`, and `animation`
with parent constraints.

### @neith/dcc-nurbs

NURBS curves and surfaces (Rust, `libs/neith/dcc-nurbs`, phase 171.17):
Cox-de-Boor `basis` with knot insertion, rational `curve`s (open/closed, order
N, weights), `surface` patches with tessellation, `trim` curves,
loft/revolve/sweep/bevel `operations`, `continuity` constraint editing, and an
IGES/STEP `import` path plus hair-guide NURBS.

### @neith/dcc-preferences

Preferences and keymap system (Rust, `libs/neith/dcc-preferences`, phase
171.19): a searchable `prefs` model, a `keymap` editor with conflict detection,
`presets` (Blender/Maya/Max/industry-compatible), `viewport` and gizmo defaults,
auto-save/recent/startup `files` handling, `addons` enablement, per-`project`
overrides, and portable preference `bundle`s.

### @neith/dcc-text3d

3D text object (Rust, `libs/neith/dcc-text3d`, phase 171.18): `font` model with
kerning and OpenType feature tags, paragraph `layout`
(kerning/tracking/leading/alignment), `bidi` script detection with RTL
reordering, `variable`-font axes, glyph-outline `extrude` with bevel/taper,
text-`oncurve`, and ear-clip triangulated `glyphs` for text-to-mesh.

### @neith/delivery

Cinema/broadcast delivery and QC core (Rust, `libs/neith/delivery`, phase
135.7): a 41-module crate spanning DCP mastering (`jpeg2000`, `mxf`, `cpl`,
`kdm`), IMF (`imf_documents`, supplemental packages, Photon-style `validator`),
Dolby Vision/HDR10+ metadata, Atmos/`adm_bwf` audio delivery, ABR/`cmaf`
streaming presets, and automated QC (`signal_qc`, `pse_qc`, loudness, cadence,
subtitles).

### @neith/dh-animator

Digital-human performance-capture animator (Rust, `libs/neith/dh-animator`,
phase 162.8), built on `neith-dh-core`: monocular/HMC/depth `face_solve` with
marker hybrid, audio `viseme_solve`, `body_retarget` and finger solving,
`tongue_teeth` and `breath` inference, `motionmatch`, gaze conditioning,
clean-up filters, a keyframe editor, and farm `batch` processing.

### @neith/dh-bodyrig

Digital-human body rig and deformation (Rust, `libs/neith/dh-bodyrig`, phase
162.5): `biped`/`quadruped` skeletons, LBS/DQS `skin`ning, `muscle`-bulge
blendshapes, `jiggle` joints, `volume` preservation, two-bone/FABRIK/CCD `ik`
plus full-body `fbik`, foot placement, spine ribbon, breathing, 25-bone `hand`s,
space switching, and a rig `variants` library.

### @neith/dh-clothing

Digital garment system (Rust, `libs/neith/dh-clothing`, phase 162.7): seven
garment `presets`, a 2D cut-`pattern` model with ASCII-DXF import (the Marvelous
binary format is a fail-loud seam), stitch/`seam` authoring, a `fabric` library,
`drape` simulation, `fit`-to-body, `layering` order, and cloth `lod` cards —
deterministic geometry and physics on `neith-dh-core` types.

### @neith/dh-core

Shared spine of the phase-162 MetaHuman-class digital-human pipeline (Rust,
`libs/neith/dh-core`): dependency-free `math` (Vec/Quat/Mat4), triangle `mesh`
with UDIM UVs, `skeleton` bind-pose evaluation, sparse `blendshape` stacks,
LBS/DQS `skinning`, and the `facs`/`viseme` descriptor vocabulary every other
dh-\* crate builds on.

### @neith/dh-creator

Character creator (Rust, `libs/neith/dh-creator`, phase 162.1): parametric
`face`/`body` morph dials with calibrated ageing/dimorphism curves, a
Beer-Lambert melanin/haemoglobin `skin`-tone model with CIELAB/ITA
classification, Perlin-style `micro`-geometry, a least-squares landmark
`photofit`, an OBJ `importscan` path, and a UDIM `uvlayout` auto-packer — all
seeded and deterministic.

### @neith/dh-ethics

Likeness, consent, and provenance governance for digital humans (Rust,
`libs/neith/dh-ethics`, phase 162.12): signed actor `consent` forms, a
hash-chained tamper-evident `ledger` with fail-closed queries and revocation, an
LSB-steganography likeness `watermark` with checksum-validated detection, an
append-only `usage` log, `agegate` and `synthetic`-only flags, and a `royalty`
split model.

### @neith/dh-eyes

Ocular system (Rust, `libs/neith/dh-eyes`, phase 162.3): parametric
cornea/iris/sclera `geometry` with dual-layer shading, Snell's-law `refraction`
through the cornea, iris `parallax`, wet-line `meniscus` and `tears`, `pupil`
dilation, `saccade` jitter, `vergence`, and a `blink` library — real ocular
geometry and oculomotor dynamics, CPU-deterministic.

### @neith/dh-facerig

Facial rig (Rust, `libs/neith/dh-facerig`, phase 162.4): FACS 48-action-unit
`blendshapes` library, a `hybrid` joint+blendshape rig with `correctives`, a
`rom` range-of-motion harness, `wrinkle` maps, `visemes`, tongue/jaw/neck
kinematics, control curves, a pose library, and runtime `stripping` with a
sub-millisecond `solver` budget.

### @neith/dh-retarget

Animation retarget and library plane (Rust, `libs/neith/dh-retarget`, phase
162.10): skeleton `bonemap`ping with twist hints, `clip` retarget with IK foot
lock, `proportion` retarget, `posespace` interpolation, Mixamo/HumanIK
`convention` import and Mannequin/MetaHuman maps, foot-slide `fixup`, a rig
`switcher`, and runtime `baking`.

### @neith/dh-sdk

Runtime SDK and game integration for digital humans (Rust, `libs/neith/dh-sdk`,
phase 162.11): a `streaming` asset loader, `lod` chain with impostors,
`gpu_skin`/morph packing descriptors, `groom`/`garment` bind, a runtime
`facerig_solver`, memory `budget`, `crowd` instancing, and `pixel_stream` plus
Unreal/Unity/Godot `plugin` descriptors (descriptor models, not engine-linked
plugins).

### @neith/dh-sim

Ziva-class flesh simulation (Rust, `libs/neith/dh-sim`, phase 162.6):
tetrahedral co-rotational `fem` muscle, `fat` soft body, sliding `skin`, an
`anatomy` library, `activation` maps, `contact` deformation, a learned skinning
`deformer`, sim `cache`/replay, and LOD/`realtime` hero options — all CPU
physics on `neith-dh-core` types, fully deterministic.

### @neith/dh-skin

Physically-based skin material (Rust, `libs/neith/dh-skin`, phase 162.2):
Burley + sum-of-Gaussians `sss` with measured per-channel scatter distances,
Cook-Torrance/GGX `specular` with mesoscopic per-pore roughness, procedural
`pores` normal maps, `wetness`/`bloodflow`/goosebumps dynamics, and
birthmark/tattoo/makeup layers — CPU-evaluable shading math, no GPU dependency.

### @neith/dh-testing

Testing and validation suite for the digital-human stack (Rust,
`libs/neith/dh-testing`, phase 162.13) — a validation crate, not a runtime
feature: `image_metrics` (MSE/PSNR/SSIM) against references, `facs_coverage`
checks, `lipsync` timing offsets, `solver_budget` gates, `foot_slide` RMS,
MetaHuman-import and `cross_engine` export conformance, and a `consent_ledger`
audit.

### @neith/dh-voice

Voice and speech bridge (Rust, `libs/neith/dh-voice`, phase 162.9):
per-character voice `model`s, a consent-gated + watermarked `cloning` path,
`emotion` prosody parameters, a forced phoneme `aligner`, `viseme_map`ping with
coarticulation, and `dtw`-based `dubbing` auto-alignment. Neural TTS and
voice-clone models are honestly external behind the `SynthBackend` seam, which
reports `NotConfigured` until a backend is bound.

### @neith/dit

DIT, dailies, and on-set media pipeline core (Rust, `libs/neith/dit`, phase
135.6): a 24-module crate covering `card_ingest` with `mhl`/`hash` verification,
`cdl` handling and `cdl_authoring`, `dailies` and `proxy` generation models,
`camera_report`/`sound_report`/`dit_report` paperwork, `ltfs` archive, and
review/`preview_link` delivery.

### @neith/engine-anim-insights

Animation debugging and insights (Rust, `libs/neith/engine-anim-insights`, phase
171.14): per-frame anim-graph `record` dumps, `posecache` evolution series,
montage/`notify` trails with slot-weight history, a real FABRIK `ik` iteration
breakdown, `retarget` deltas, a `gauntlet`-style auto-test harness, cross-build
`diff`, and statistical `regression` alerting — Unreal Animation Insights +
Rewind Debugger territory.

### @neith/engine-chooser

Chooser tables and data-driven selection (Rust, `libs/neith/engine-chooser`,
phase 171.10): a `table` asset of if-`context`-then-pick rows with composite
`condition`s (tag/bool/range), first-match, weighted and chained evaluation with
a debug trace, `hotreload`, CSV/JSON `import`, and StateTree/BT `integration`
adapters — Unreal's Chooser Table plugin as a sovereign model.

### @neith/engine-input

Enhanced-input system (Rust, `libs/neith/engine-input`, phase 172.1): input
`action` assets and mapping contexts with priority stacking in `subsystem`, a
`modifiers` pipeline (dead-zone/smooth/swizzle/response-curve), a `triggers`
pipeline (tap/hold/chord/pulse), device `keys` models, runtime `rebind`ing,
`accessibility` options, and input `record`/replay.

### @neith/engine-level-instances

Level instances and packed level actors (Rust,
`libs/neith/engine-level-instances`, phase 171.3): reusable sub-`level`
`instance`s with per-instance overrides, `packed` static-mesh baking into
instanced batches, `nested` instances with override propagation,
`worldpartition` streaming-cell assignment, `hlod` proxy generation, and
`datalayer` gating.

### @neith/engine-lights

Area and photometric lights (Rust, `libs/neith/engine-lights`, phase 171.6):
rect/disc/tube `area` emitters with solid-angle sampling, mesh-`emissive` light
sampling, `ies` profile loading with polar preview, `gobo` projection,
`barndoor`/spot masks, `falloff` editing, and `pathtrace` importance sampling
with MIS, plus a light-`mixer` console model.

### @neith/engine-lwc

Large-world coordinates (Rust, `libs/neith/engine-lwc`, phase 171.2): an f64
world substrate — `dvec` vectors with f32 parity, f64 TRS `transform`s with
split-precision upload, floating-`origin` rebasing near the camera, an f64
symplectic `physics` path, `camera_relative` translation for the f32 renderer,
and quantised `netcompress` delta compression of 64-bit coordinates.

### @neith/engine-mdf

Mesh distance fields and global distance field (Rust, `libs/neith/engine-mdf`,
phase 171.8): mesh-to-SDF `generate` baking, a composited `global` scene field
with sphere tracing, landscape `heightfield` SDFs, cone-traced `ao` and penumbra
soft `shadow`s, VFX particle `collision`, and SDF `streaming`/LOD — the
software-raytracing substrate of the renderer.

### @neith/engine-megalights

MegaLights-class many-light renderer (Rust, `libs/neith/engine-megalights`,
phase 171.4): a ReSTIR direct-illumination integrator (`restir`) with
weighted-`reservoir` RIS and temporal/spatial reuse, per-light `importance`
scoring with CDFs, point/spot/rect/disc/tube `light` sampling, `ies` profiles,
and skin/hair/translucent `materials` BSDFs — validated against a reference
estimator.

### @neith/engine-modeling

In-editor modeling mode and geometry script (Rust, `libs/neith/engine-modeling`,
phase 171.7): an editable indexed `mesh` with an extrude/inset/bevel/knife
`toolkit`, `polyedit` selection and transforms, SDF-`voxel` mesh `boolean`s,
shrinkwrap `retopo`, planar/box/cylindrical `uv` unwrap with shelf packing, and
a headless composable `geoscript` surface. Its stable `node_library` exposes
more than 200 unique primitive, selection, topology, Boolean, deform, retopo,
UV, attribute, bake, and query nodes; named invocations lower into the same cook
IR used by visual and text scripting, and the parity corpus executes every node.

### @neith/engine-motion-design

Cinema4D-MoGraph-class motion-design toolkit (Rust,
`libs/neith/engine-motion-design`, phase 171.12): grid/linear/radial `cloner`s,
plain/random/step/noise `effector`s modulated by `field`s, animated Catmull-Rom
`spline` paths, `spawner`/sequencer time integration, text-on-path kinetic
typography, a `templates` library, and a `broadcast`-output bridge.

### @neith/engine-pose-search

Pose search / motion matching (Rust, `libs/neith/engine-pose-search`, phase
171.11): a pose `database` of motion `feature` vectors with channel-weighted
K-NN cost, a `kdtree` ANN index, spring-damper `trajectory` prediction,
inertialization `blend`-out with overshoot control, and a motion-`warp` layer —
Unreal's Pose Search plugin as a sovereign runtime.

### @neith/engine-rvt

Runtime virtual textures (Rust, `libs/neith/engine-rvt`, phase 171.5): a virtual
`page` table and physical `atlas` with GPU-style `feedback` and LRU `cache`
paging, disk `streaming` with neighbour prefetch, multi-`layer` RVT tile types
(colour/normal/height/mask), `landscape` terrain blend, and decal/weather
`accumulate` writers.

### @neith/engine-scale

Open-world scale systems (Rust, `libs/neith/engine-scale`, phase 171.15):
`foliage` volumes with per-instance LOD and HISM clustering, `grass` density
painting, spline-driven `landmass` edits over a shared `heightfield`, `water`
bodies with `gerstner` wave displacement, `shoreline` foam, `underwater`
post-processing, and hydraulic `erosion`.

### @neith/engine-smart-objects

Smart objects and gameplay interactions (Rust,
`libs/neith/engine-smart-objects`, phase 171.9): smart-`object` assets with
interaction slots, a claim/perform/release `interaction` lifecycle with
occupancy tracking, hierarchical gameplay `tags` with query, `utility`-AI
scoring, an `ai` selection loop, and a runtime `registry` plus `replication`
hooks.

### @neith/engine-state-tree

StateTree/BehaviorTree convergence (Rust, `libs/neith/engine-state-tree`, phase
171.13): a hierarchical FSM + utility + BT runtime — selector/sequence/
parallel/task/condition `node`s, a global/local scoped `blackboard`, `events`
listeners, EQS and smart-object `integration` hooks, live-editable `tree`
instances, `profiling`, and a behaviour `templates` library.

### @neith/engine-verse

Verse-class scripting stack (Rust, `libs/neith/engine-verse`, phase 171.1): a
strongly-typed, concurrent, failure-aware language — `lexer`/`parser`/`check`
front-end, `ir` compilation, a sandboxed transactional `vm` with resource
quotas, `hotreload` with state migration, a live `repl`, a Blueprint-class
`visual` scripting surface targeting the same IR, and a static-`analysis`
distribution gate.

### @neith/forge-board

Whiteboard and diagramming primitives (Rust, `libs/neith/forge-board`) — a
single-file ~11K-line crate (233 pub fns, 105 tests) of typed board operations:
`BoardRect`/`CanvasTileCoord` geometry, sticky notes (`StickyNoteColor`), and
`CaptureExport` region/format export planning.

### @neith/forge-fonts

Font-editor primitives (Rust, `libs/neith/forge-fonts`) — a single-file
~10.7K-line crate modelling glyph outlines (`Glyph`, `GlyphContour`,
`GlyphNode`), `FontMetrics` and guides, and auto-hinting (`AutoHintOptions`,
stem-hint orientation) with per-operation tests.

### @neith/forge-genimaging

Generative-imaging workflow primitives (Rust, `libs/neith/forge-genimaging`,
~3.7K lines): typed models and operations for text-to-image canvases
(`TextToImagePrompt`, `GenerationSettings`, `DiffusionSampler`), masked
`GenerativeFillRequest`s, reference images, and canvas expansion — the workflow
layer only; diffusion model inference is not in this crate.

### @neith/forge-icon

Icon and brand-asset primitives (Rust, `libs/neith/forge-icon`, ~2.2K lines):
`PixelGrid` icon templates across standard `IconSize`s, SVG optimisation
(`SvgOptimizeOptions`), icon-font builds (`IconFontBuild`), and multi-density
raster export planning (`RasterExportPlan`).

### @neith/forge-motion

Interactive motion-graphics primitives (Rust, `libs/neith/forge-motion`, ~3.2K
lines): keyframed `VectorTimeline`s with `Easing`, animated-property tracks, and
a Rive-style interactive `StateMachine` with `StateInput`s and condition-guarded
`StateTransition`s.

### @neith/forge-photo

Photography catalog and RAW workflow primitives (Rust, `libs/neith/forge-photo`)
— a single-file ~12.6K-line crate (202 pub fns, 120 tests):
`ImportSource`/`PhotoAsset` catalog operations plus USB and Wi-Fi tethering
session/capture models (`UsbTetherSession`, `WifiTetherProtocol`) — typed
workflow state, not camera device drivers.

### @neith/forge-publisher

Long-document publishing primitives (Rust, `libs/neith/forge-publisher`, ~12.2K
lines): `PrintPageSetup` page geometry with edge insets and `PrintMark`s, and
PDF/X export planning (`PdfXStandard`, `PdfOutputIntent`, `PdfXExportOptions`)
for print production.

### @neith/foundry

Nuke-class node-compositor core (Rust, `libs/neith/foundry`, phase 135.1): an
80-module crate composing the shared Neith DAG with image-specific nodes —
keying (`keylight`, `primatte`, `ibk`), `roto`/`paint_stroke`, `cryptomatte` and
`deep` compositing, `ocio`/ACES colour, 2D/planar/camera tracking,
`scanline_render`/`ray_render` 3D, and Python/Lua/Tcl API surfaces. Host
boundaries like image decode/encode stay explicit and deterministic.

### @neith/gi-ao

Ambient-occlusion suite (Rust, `libs/neith/gi-ao`, phase 168.8): horizon-based
`gtao` (XeGTAO-class) with bent normals, ray-traced `rtao`, Jimenez
`multibounce` energy recovery, distance-field `dfao` cone tracing, analytic
`capsule_ao` for characters, `thickness`-map transmission, and a `contribution`
stage applying AO to indirect light only.

### @neith/gi-conformance

Cross-crate conformance suite for the phase-168 GI pipeline
(`libs/neith/gi-conformance`) — a validation crate: canonical `scenes` built in
every technique's representation, reference-vs-realtime `rmse`, `temporal`
stability and `moving`-object robustness checks, a `shadow_corpus`, per-profile
`memory` budgets, and fail-loud `external` gates for cross-GPU parity and
mobile/console frame-rate targets that need real hardware.

### @neith/gi-core

Unified GI abstraction and render graph (Rust, `libs/neith/gi-core`, phase
168.1): implements no single GI algorithm itself — it defines the
diffuse/specular/shadow `interface` the technique crates satisfy, quality
`profile` tiers, a `capability`-driven `fallback` chain (HW-RT → SW-RT → SDFGI →
probes), render-`graph` scheduling, `budget`s, and a path-traced `reference` for
validation.

### @neith/gi-emissive

Emissive light injection (Rust, `libs/neith/gi-emissive`, phase 168.10):
emissive triangles become area lights via `mesh_light` with per-triangle
sampling, froxel `cluster_inject`ion, one-bounce `gi_contribution`, luminance
`importance` sampling, incremental `moving`-object updates, distance `lod`
cutoff, and HDR `bloom` feed — sprites and VFX emit too.

### @neith/gi-lightmap

Progressive/baked lightmapping (Rust, `libs/neith/gi-lightmap`, phase 168.7):
UV-chart `atlas` generation and packing, a path-traced `baker` with a
progressive-`radiosity` fallback, a tiled `gpu`-style bake scheduler,
`directional` dominant-direction lightmaps, `mixed` static+dynamic lighting with
stationary subtractive support, and a seam-aware `denoise`r — Unity Progressive
Lightmapper / Lightmass territory.

### @neith/gi-lumen

Lumen-class software + hardware ray-trace GI (Rust, `libs/neith/gi-lumen`, phase
168.5): a SAH `bvh` with Möller–Trumbore traversal, hardware and software
`trace` paths, an on-mesh `surface_cache` and world `radiance_cache`,
`screen_probe` final gather, `restir` (ReSTIR-GI) spatiotemporal reservoir
resampling, and SVGF `denoise`. Also serves as the pipeline's path-traced
reference.

### @neith/gi-probe

Irradiance and reflection probe system (Rust, `libs/neith/gi-probe`, phase
168.4): order-2 `sh` irradiance probes, a `ddgi` dynamic diffuse grid with
`octahedral` encoding and Chebyshev visibility, prefiltered cubemap
`reflection_probe`s and `planar_probe`s, auto-`placement` with inside-geometry
relocation, and runtime/offline `bake` plus `streaming`.

### @neith/gi-sdfgi

Signed-distance-field GI (Rust, `libs/neith/gi-sdfgi`, phase 168.2): scene
meshes baked to an `sdf` grid by exact point-to-triangle distance,
camera-centred `cascade` clipmaps with incremental scrolling and dirty regions,
per-voxel `albedo`+emission, hemisphere `cone_trace` diffuse and sharp specular,
`sky` fallback, and a `denoise` pass — Godot-SDFGI / Brixelizer-class, no
lightmaps.

### @neith/gi-shadow

Unified shadow pipeline (Rust, `libs/neith/gi-shadow`, phase 168.6): `vsm`
virtual shadow maps with a sparse page table, `csm` cascades with soft
transitions, `raytraced` and stochastic PCSS soft shadows, screen-space
`contact` shadows, hair `strand` and `translucent` shadows, and a distance
`lod` + per-light `budget` — a `ShadowPipeline` selects the technique and
answers the `gi-core` `ShadowGi` query.

### @neith/gi-sky

Sky, atmosphere, and time-of-day (Rust, `libs/neith/gi-sky`, phase 168.11): a
Bruneton-style Rayleigh/Mie `atmosphere` with aerial perspective, `celestial`
sun/moon/star ephemeris with eclipse and aurora events, `weather`-driven
parameters, a sky-to-`cubemap`-to-SH bake feeding `sky_gi`, dynamic cloud
shadows, and a keyframed `timeofday` timeline composed by the `Sky` type.

### @neith/gi-volumetric

Volumetric lighting (Rust, `libs/neith/gi-volumetric`, phase 168.9): a `froxel`
frustum-voxel scattering integrator over HG/Rayleigh `phase` functions,
analytic + heterogeneous VDB-style `density` fields, volumetric
self-`shadow`ing, `godrays`, sun-lit ray-marched `clouds`, in-volume `caustics`
approximation, and a volumetric `denoise`r.

### @neith/gi-voxel

Voxel GI (Rust, `libs/neith/gi-voxel`, phase 168.3): a sparse voxel `octree`
with surface voxelisation, anisotropic six-face `radiance` with emissive
injection, a front-to-back `mipmap` pyramid, `cone_trace` lookup for diffuse and
specular GI, an `irradiance_cache`, per-light voxel `shadow`, and region
`streaming` — SVOGI/VXGI-class, fully dynamic.

### @neith/gpen-anim

Grease-pencil 2D animation workflow (Rust, `libs/neith/gpen-anim`, phase 156.3),
built on the `neith-gpen-object` data model: `onion`-skin ghosting, cubic stroke
`inbetween` tweens driven by an `fcurve`, a `dopesheet` and `xsheet`,
`cycles`/`walkcycle` looping, `lipsync` mouth charts, and animatic timing.

### @neith/gpen-lineart

Line art from 3D (Rust, `libs/neith/gpen-lineart`, phase 156.5): views a
triangle `mesh` through a camera and emits grease-pencil strokes for silhouettes
(`contour`), `crease`s, material boundaries and `intersect`ions, `chain`ed into
editable polylines with `occlusion` culling, material-driven `style`, and
`noise` roughening — Blender Line Art / Pencil+ territory, with a `gpu` path.

### @neith/gpen-modifier

Grease-pencil modifier evaluator (Rust, `libs/neith/gpen-modifier`, phase
156.4): one real deformation algorithm per modifier kind — `armature`, `array`,
`build`, `lattice`, `mirror`, `noise`, `smooth`, `shrinkwrap`, `dotdash` and
more — evaluated over a layer's strokes by a `ModifierPipeline` threading a
shared `ModifierContext`; every modifier is a pure, deterministic function of
parameters and context.

### @neith/gpen-object

Foundation data model of the grease-pencil suite (Rust,
`libs/neith/gpen-object`, phase 156.1): `GpObject` → `layer`s → sparse `frame`
lists → `stroke`s of points, plus `fill`s, `material`s, `shapekey`s, the `math`
kernel, and a `usd` custom-prim/BasisCurves exporter — every other gpen-\* crate
builds on this spine.

### @neith/gpen-rig

2D character rigging for grease pencil (Rust, `libs/neith/gpen-rig`, phase
156.7): `armature` FK skeletons, envelope auto-`weights`, linear-blend `skin` of
strokes, CCD/FABRIK `ik`, mean-value-coordinate `cage` deform, blendshape
`expression` rigs, and an `autorig` body template — Toon Boom/Moho-class cut-out
puppetry.

### @neith/gpen-shade

Materials and rendering for grease pencil (Rust, `libs/neith/gpen-shade`, phase
156.6): a software MSAA `raster`izer with multi-`aov` framebuffer,
solid/gradient/texture/pattern `shader`s with stencil alpha, lit strokes and
shadows in `light`, layer `blend` modes, stroke `sort`ing, and a `gpu` (wgpu)
path.

### @neith/gpen-storyboard

Storyboard and previs (Rust, `libs/neith/gpen-storyboard`, phase 156.9): a
`board` panel manager, an Act→Scene→Shot→Board `hierarchy` with roll-up timing,
a keyframed storyboard `camera` widget, per-board `sidecar` metadata, `animatic`
assembly, and `edl`/`otio`/`pdf` export — Storyboard-Pro territory on the
grease-pencil model.

### @neith/gpen-testing

Cross-crate validation harness for the grease-pencil suite (Rust,
`libs/neith/gpen-testing`, phase 156.10) — a testing crate that depends on every
gpen-\* sibling: 100k-stroke `perf` scenes, `usda` round-trip checks, and
`integration` runs (cross-NPR consistency, an end-to-end animated short, the
phase-141 X-sheet hand-off).

### @neith/gpen-tools

Interaction layer of the grease-pencil suite (Rust, `libs/neith/gpen-tools`,
phase 156.2): `draw` with `brush` presets, pressure curves and a `stabilizer`,
`fill_ops` (flood fill via the foundation ear-clipper), `sculpt` and `edit`
reshaping, `select` modes, `guides`, and `surface` projection — everything
between pen-down and a finished drawing.

### @neith/gpen-vr

VR/AR spatial drawing (Rust, `libs/neith/gpen-vr`, phase 156.8): 6DoF controller
`input` to stroke ingestion via a `quat` kernel, AR anchor-relative `placement`,
tube/ribbon/billboard `volumetric` geometry, `gesture`s, and CRDT-based
`collab`/`sync` multi-artist sessions — a Quill/Open-Brush-class layer whose
strokes stay first-class grease-pencil data.

### @neith/hair-anim

Hair animation and rigging for curve grooms (Rust, `libs/neith/hair-anim`, phase
155.9): rest/dynamic `pose` blending, `bake` of simulation to sparse keyframes,
`blend`shapes with layer blends and correctives, `motion`-vector computation,
`control`-curve rigging, `lattice` FFD deformation, and an animatable `wind`
driver.

### @neith/hair-curve

Foundation of the phase-155 curves-hair system (Rust, `libs/neith/hair-curve`):
a first-class `Curve` strand type with Poly/Bézier/Catmull-Rom/B-Spline bases,
typed columnar `attribute`s, a `CurveSet` scene object with layered
`eval`uation, surface `anchor`ing, `instance`s, and `lod` — the data model every
other hair-\* crate mutates.

### @neith/hair-groom

Grooming brushes and tools (Rust, `libs/neith/hair-groom`, phase 155.2): every
brush consumes a `BrushStroke` soft radial region and mutates a `CurveSet` in
place — `topology` add/remove/density, `deform` comb and smooth, `length`
grow/trim, `clump` with soft core, plus `mask` and `mirror` support —
XGen-Interactive/Ornatrix-class sculpting.

### @neith/hair-guide

Guide curves and interpolation (Rust, `libs/neith/hair-guide`, phase 155.4):
sparse authored `guide` strands interpolated to a full groom via N-nearest,
Gaussian `rbf`, and UV-aware `interp` with priority layering, `weight` painting,
and feather/bilateral `symmetry` mirroring.

### @neith/hair-nodes

Geometry-node graph for curves (Rust, `libs/neith/hair-nodes`, phase 155.3):
procedural nodes transforming a `CurveSet` — `scatter` from surface/density map,
`generate` from guides, `edit` (trim/resample/set-radius), `shape`
(turbulence/curl/frizz), `braid` and `clump` — composed by a `NodeGraph` and
wired into looks by `presets`.

### @neith/hair-presets

Groom preset library (Rust, `libs/neith/hair-presets`, phase 155.8): 250+
parametric strand grooms — `human` hair including afro/coily grades, beards,
braids and wigs, `creature` fur/feathers/scales, `stylised` looks, and
`accessory` mesh descriptors — each `GroomPreset` carrying an `Attribution` and
able to emit a shaping node graph.

### @neith/hair-render

Hair rendering geometry and LOD (Rust, `libs/neith/hair-render`, phase 155.7):
strand-to-tube/ribbon `mesh` generation, `raytrace` ray-strand intersection,
weighted-blended `oit` transparency, stochastic alpha-tested `shadow`s,
strand→clump→`card` distance `lod` with cross-fade and auto card baking, plus
`billboard`s and `motion` blur — CPU math, renderer-facing.

### @neith/hair-shade

Hair shading (Rust, `libs/neith/hair-shade`, phase 155.6): the two production
BSDFs — `marschner` far-field and `chiang` near-field — plus `kajiya`-Kay
stylised shading, melanin-based `color`, `dual_scatter` multiple scattering,
`aov`/Cryptomatte outputs, and LOD-aware billboard shading.

### @neith/hair-sim

Hair simulation and dynamics (Rust, `libs/neith/hair-sim`, phase 155.5): a CPU
strand solver — `der` discrete-elastic-rod bending/twist, `pbd` constraints with
`fast_projection` inextensibility, self/body `collide`, gravity/wind `forces`,
wet-hair `material`s, sim `lod`, `cache` baking, and `rig`-driven roots.

### @neith/hair-transfer

Cross-mesh groom transfer (Rust, `libs/neith/hair-transfer`, phase 155.10):
UV-projection `transfer` with auto-scale, cross-topology and retopo support over
a `uv_map` triangle lookup, `morph`-target resync, portable groom-pack
`bundle`s, hair-scalp `fit` checking, cross-character `retarget`ing, and
`partline` relocation.

### @neith/hair-validation

Cross-crate validation for the hair suite (Rust, `libs/neith/hair-validation`,
phase 155.11) — a testing crate with the integration tests in
`tests/validation.rs`: deterministic simulation stability, afro/coily texture
fidelity, and groom `transfer` across a synthetic head set. Items needing a
viewport, offline renderer, or external interchange (1M-strand renders,
USD/Alembic round-trips, Arnold comparison) are honestly out of scope here.

### @neith/hdr

HDR mastering core (Rust, `libs/neith/hdr`, phase 135.9): `dolby_xml` metadata
and trim levels, `hdr10plus`, `hlg` and `pq` transfer handling, `aces` colour,
`sdr_tonemap` and `display_mapping` preview, `colorimetry`, and `automated_trim`
— the mastering/delivery metadata plane for HDR finishing.

### @neith/liveops-ads

Ad mediation and SDK (Rust, `libs/neith/liveops-ads`, phase 164.2): a sealed-bid
first/second-price `auction`, per-network mediation `adapters`,
`waterfall`/header-bidding allocation, `frequency` caps and `pacing`, HMAC
server-side `reward` verification, COPPA `kids`-mode and GDPR/ATT `consent`
gating, click/install `fraud` guards, and eCPM/fill `report`ing.

### @neith/liveops-analytics

Game analytics (Rust, `libs/neith/liveops-analytics`, phase 164.3): an `event`
envelope with per-platform SDK clients, inactivity-gap `session`ization,
`funnel`s, player `profile`s, `economy` source-sink flow, DAU/MAU `retention`,
LTV/ARPU `revenue`, a `cohort` builder and boolean `segment` engine, and NDJSON
warehouse `export` — deterministic throughout (time is an explicit parameter,
never a wall clock).

### @neith/liveops-attribution

Mobile attribution and growth (Rust, `libs/neith/liveops-attribution`, phase
164.8): last-touch `install` attribution, deferred `deeplink`s, `skan`
(SKAdNetwork) postbacks with 6-bit conversion values, k-anonymous `privacy`
aggregation, HMAC partner `postback`s, click-`fraud` detection, cohort `ltv`
projection, `mta` multi-touch, and `incrementality` testing — Adjust/AppsFlyer
territory, wall-clock-free.

### @neith/liveops-cloud-save

Cloud save and inventory sync (Rust, `libs/neith/liveops-cloud-save`, phase
164.7): a versioned per-slot `kv` store with `crdt` (LWW-register + OR-Set)
merge, version `history`, block-`delta` sync, ChaCha20 `crypto` at rest,
`offline`-first background sync, Steam/Epic/sovereign `backend` seams, schema
`migration`, GDPR `erasure`, and `tamper` detection.

### @neith/liveops-compliance

Regional regulatory compliance (Rust, `libs/neith/liveops-compliance`, phase
164.11): each module encodes a real regime as deterministic rules — `lootbox`
disclosure/legality with a gambling test, `age`-rating plus COPPA/GDPR-K gates,
China-minor `playtime` curfew and break notices, rolling `spend` caps,
data-`residency` routing, and right-to-`erasure` automation.

### @neith/liveops-conformance

Cross-crate conformance harnesses for the phase-164 liveops stack (Rust,
`libs/neith/liveops-conformance`) — a validation crate: `receipt_conformance`
(Apple/Google/sovereign IAP), `ad_benchmark` fill/auction correctness,
`remote_consistency` rollout monotonicity, `experiment_srm` alarms, and a
`fraud_redteam` harness, each returning a `ConformanceReport`. Its `load_test`
holds one million virtual connections live together and drives two million
remote-config/analytics SDK operations through bounded worker shards; `dogfood`
binds the real Phase 27 Project Obsidian, Phase 76 Maya Forge and Phase 77 Maya
Nexus/MMO package roots and runs each profile through all twelve liveops
runtime/operator crates.

### @neith/liveops-crm

Player CRM and lifecycle messaging (Rust, `libs/neith/liveops-crm`, phase
164.9): 360 `profile`s with RFM, cross-platform `push` and an in-game `inbox`,
`segment` auto-campaigns, `churn`/reactivation `journey` orchestration, `vip`
outreach, `consent` + frequency governance with quiet-hours, and in-campaign A/B
via `experiment` — deterministic scheduling over injected time and transport.

### @neith/liveops-cs

Customer-support and agent tooling (Rust, `libs/neith/liveops-cs`, phase
164.10): privacy-audited player `lookup`, ban/mute `sanction`s with an appeal
state machine, audited currency/item `grant`s with daily limits, save
`rollback`, incident `compensation` composer, `sla` dashboards, `chargeback`
workflow, and account `merge`/split — all on a tamper-evident SHA-256 `audit`
hash chain.

### @neith/liveops-economy

Virtual economy (Rust, `libs/neith/liveops-economy`, phase 164.6): every value
movement conserved through a double-entry `ledger` — `inventory`, `crafting`
recipes, `trading`/`marketplace`/`auction`, pity `loot` tables with drop-rate
`disclosure`, exchange caps, dup-`fraud` detection, an inflation `simulator`,
and `wealth` analytics.

### @neith/liveops-experiments

A/B and experimentation platform (Rust, `libs/neith/liveops-experiments`, phase
164.5): an experiment `definition` DSL, deterministic hash `assignment` with
mutual-exclusion layers and holdouts, a `metrics` registry with guardrails,
self-contained `stats` (erf/gamma, z/t tests, CUPED, Bayesian, SPRT sequential
early-stop), and SRM checks in `analysis` — no external numeric dependencies,
fully reproducible.

### @neith/liveops-iap

In-app purchase and storefront (Rust, `libs/neith/liveops-iap`, phase 164.1):
integer-micros `money` with banker's rounding, a cross-platform `catalog`,
StoreKit2/Google/console/Steam `receipt` validation, idempotent `entitlement`
grants, `refund` webhooks, `promo` codes, FX regional pricing with `elasticity`
A/B, `subscription` lifecycle, and VAT/GST `tax`.

### @neith/liveops-portal

Operator-portal backend (Rust, `libs/neith/liveops-portal`, phase 164.12) — data
aggregation only, no GUI: KPI `dashboard` rollups with alert states, a release
`scheduler` with dependency topo-ordering, unified config/experiment/flag
`changeset`s with approval, a `cohort` explorer, `revenue` drill-down,
`retention`/churn exploration, and a `whatif` economy simulator.

### @neith/liveops-remote

Remote config and feature flags (Rust, `libs/neith/liveops-remote`, phase
164.4): namespaced typed `value`s, a `targeting` rule engine
(segment/country/semver/device), deterministic gradual `rollout` and
`experiment` decisions from a stable FNV-1a hash of `(user_id, key)`,
kill-switch flags, an offline-fallback `client` SDK model, change `audit` +
versioned `release`/rollback, and a fetch-latency `slo`.

### @neith/market-buyer-portal

Buyer-experience layer of the creator marketplace (Rust,
`libs/neith/market-buyer-portal`, phase 165.9): owned `library` with receipts,
re-download and install tracking, `cart` with saved-for-later, `wishlist`
price-drop alerts, team/`org` purchase pooling with shared seats and budget, and
child/student `gating`.

### @neith/market-catalog

Catalog and asset-type layer of the marketplace (Rust,
`libs/neith/market-catalog`, phase 165.1): an asset `taxonomy` (3D/2D/audio/
plugin/ML-model/...), a required-field `schema` with versioned migrations,
`preview` plans (turntable/playblast/web viewer/audio waveform),
content-addressed `ids`, engine-`semver` `compat` matching, `template`s,
`collection`s, and `curation`.

### @neith/market-commerce

Money engine of the marketplace (Rust, `libs/neith/market-commerce`, phase
165.4): integer-micros `money` with banker's rounding (no f64 in the pricing
path), auto-`fx` and `ppp` purchasing-power tiers, `discount`/`pwyw`/
`preorder`/`groupbuy` mechanics, a place-of-supply `tax` engine, a transparent
`fees` waterfall, multi-currency `escrow`, chargeback `insurance`, and
collaborator revenue `split`s.

### @neith/market-conformance

Cross-crate conformance harnesses for the marketplace (Rust,
`libs/neith/market-conformance`, phase 165.12) — a validation crate driving the
real market-\* crates end-to-end: `search_load` (BM25 P99 at scale),
`commerce_audit` (20-cycle payout conservation), `security_audit` (license-cert
tampering, malware catch-rate), Unity/Fab `migration` import, an
`onboarding_soak`, and `refund_e2e`.

### @neith/market-creator

Creator onboarding (Rust, `libs/neith/market-creator`, phase 165.2): profile and
`portfolio`, a KYC/`tax`-form state machine (W-9/W-8BEN treaty rates), `payout`
and `identity` verification with real IBAN/ABA checksums, studio `team`s with
roles, a submission `wizard` with version rollback, automated asset `lint`
(missing maps, non-power-of-two, poly budget), and review-`sla` tracking.

### @neith/market-creator-analytics

Seller insights (Rust, `libs/neith/market-creator-analytics`, phase 165.10):
sales `dashboard`s with country splits, view/cart/purchase `funnel`s with refund
rates, anonymised peer-percentile `benchmark`ing, listing `seo` scoring,
`abtest`s with two-proportion z-test significance, log-log price `elasticity`
regression, and RFC-4180 CSV plus versioned bounded JSON API `export` —
closed-form `stats`, no fabricated numbers.

### @neith/market-discover

Discovery, search, and recommendations (Rust, `libs/neith/market-discover`,
phase 165.6): `bm25` keyword search with `facet` filtering, cosine `semantic`
recommendations over embeddings, perceptual-hash `visual` search, association
rule cross-sell `bundle`s, time-decayed trending `ranking`, `editorial` lists,
and a personalised `feed` — every ranking a real deterministic algorithm.

### @neith/market-dl

Asset delivery and DRM-lite (Rust, `libs/neith/market-dl`, phase 165.5):
resumable `chunk`ed download with per-chunk SHA-256, rsync-style rolling-hash
`delta` patching, `install` actions with plugin auto-enable, a fail-closed
per-user `entitlement` unpack gate, signed `offline` activation, an optional
per-buyer `watermark`, and re-download `quota` accounting — byte plans and state
machines a thin networked shell drives.

### @neith/market-licensing

Licensing and rights engine (Rust, `libs/neith/market-licensing`, phase 165.3):
`tier` rights bundles (standard/extended/enterprise), `usage` metering
(royalty/per-seat/per-title), composable custom `terms` with conflict detection,
CC and GPL/MIT/Apache templates with an SPDX-style `compat` checker,
Ed25519-signed proof-of-license `cert`s, auto-`attribution` NOTICE generation,
and a DMCA `takedown`/`dispute` workflow.

### @neith/market-moderation

Trust and safety plane of the marketplace (Rust, `libs/neith/market-moderation`,
phase 165.8): SHA-256 `malware` signature scans, `static_analysis` of plugin
scripts (dangerous-API/obfuscation heuristics), an NSFW/violence `classifier`,
`copyright`/`deepfake`/ `trademark` guards, a human review `queue` with SLAs,
`appeal` due process, `regional`/`agegate` availability, an escalating `strikes`
ledger, and a `transparency` report — all detectors pure and deterministic.

### @neith/market-review

Ratings, reviews, and QA (Rust, `libs/neith/market-review`, phase 165.7): star
`rating`s with verified-purchase weighting, Wilson-score `helpful`-vote ranking,
creator `response`s with an edit window, `guideline` flagging and enforcement,
lexicon `sentiment` with negation handling, automated `qa`-bot scene tests, and
per-category `refund` policy.

### @neith/market-sdk

Integration SDK for the marketplace (Rust, `libs/neith/market-sdk`, phase
165.11): DCC/engine/PWA `surfaces`, a `neithmarket` `cli`, publish-from-CI
idempotency in `publish`, Stripe-style HMAC-signed `webhook`s, `oauth`
(authorization-code + PKCE S256), licensed-asset verification, `inventory` sync
diffing, and signed embed-buy `widget`s — genuine SHA-256/HMAC/PKCE, not mocks.

### @neith/matchmove

Camera tracking and matchmove core (Rust, `libs/neith/matchmove`, phase 135.4):
a 19-module crate covering 2D `tracking` and `object_track`ing, lens solve with
a `lens_database`, `bundle` adjustment, `survey` and `nodal` solves,
`multi_view` reconstruction, `point_cloud`/`mesh` output with textured export,
`gaussian_splat` output, and drift `diagnostics`.

### @neith/motion

After Effects-class motion-graphics composition core (Rust, `libs/neith/motion`,
phase 135.2): frame-exact nested compositions — `shape` and `text` layers, an
`expression` engine, 3D `camera`/`light`/`raytrace`, `particle`s, `graph`-editor
curves, `time` remapping, `template`s, and `dynamic_link` — a ~1.2K-line lib.rs
orchestrating 16 modules.

### @neith/npr-cel

Cel/toon shading pipeline (Rust, `libs/neith/npr-cel`, phase 170.11, built on
`neith-sculpt-core`): a multi-step diffuse `ramp` with shadow tiers and stepped
specular, `features` (skin-tone ramp, anisotropic hair streak, eye card, rim
layer), `detail` (SDF hard shadows, posture correction, face-normal bake),
`layered` cel materials, and a shared realtime/offline `parity` kernel —
Guilty-Gear/Pencil+4 territory.

### @neith/npr-inking

Inking and hatching pipeline (Rust, `libs/neith/npr-inking`, phase 170.12):
illuminance-driven `hatch` density with progressive cross-hatch angle ramps and
curvature-aligned direction, rotated-screen `halftone` dots with a manga
screentone library, pencil/charcoal/ink/etching `presets`, and paper-texture
`composite` with unified stylised edges.

### @neith/npr-line

Freestyle-class offline line renderer (Rust, `libs/neith/npr-line`, phase
170.10): feature-`edges` detection (silhouette, crease, ridge/valley, suggestive
contour), stroke chaining with prune/sort in `stroke`, a `shader` modifier
chain, dash/dot `pattern`s with tapered caps, hand-drawn `jitter`, `occlusion`,
and temporal `stability` — built on `neith-sculpt-core`.

### @neith/oss-abstraction

Platform-agnostic foundation of the phase-159 online stack (Rust,
`libs/neith/oss-abstraction`): gameplay code targets one `IOnlineSubsystem`
trait; `backends` hold a `NullBackend`, a first-party `SovereignBackend`, a
`BackendRegistry` and external-SDK bridge seams, plus real `mdns` LAN discovery,
`capability` flags, `hotswap`, and `compliance` checks.

### @neith/oss-anti-cheat

Server-authoritative anti-cheat (Rust, `libs/neith/oss-anti-cheat`, phase
159.13) — the server never trusts the client: kinematic `movement` reachability
checks against teleports/speed-hacks, server-side `hitreg` re-derivation,
`packet` and `ratelimit` guards, statistical `anomaly` models, and a `review`
pipeline. OS-level code-signing `attestation` and the trust service are explicit
fail-loud seams.

### @neith/oss-identity

Identity, auth, friends, and presence (Rust, `libs/neith/oss-identity`, phase
159.2): a sovereign `PlayerIdentity` aggregating linked `platform` accounts, a
deterministic SHA-256 `stable_id`, real `oidc` ID-token claim validation,
`webauthn`, `friends`/`presence`/`moderation` state, `guest` accounts, and
`crossplay` policy.

### @neith/oss-matchmaking

Matchmaking, lobby, and party (Rust, `libs/neith/oss-matchmaking`, phase 159.3)
— engine-agnostic policy and math with no network I/O: a `lobby` directory with
typed attributes and an inverted search index, single-use `invite` deep-link
tokens, a persistent `party` service, `ready`-check countdowns, skill `rating`
(Glicko-class), `hopper`/`backfill` queues, `region` selection, and `smurf`
detection.

### @neith/oss-observability

Net telemetry and profiler (Rust, `libs/neith/oss-observability`, phase 159.14):
per-`connection` RTT (RFC 6298 SRTT/RTTVAR), RFC 3550 interarrival jitter and
sequence-gap loss, `bandwidth` attribution with top-N hotspots, `capture` and
`timeseries` models, `slo` tracking, and `regression` detection — replaying a
recorded packet log yields identical numbers.

### @neith/oss-pixel

Pixel streaming and cloud game output (Rust, `libs/neith/oss-pixel`, phase
159.12): the protocol/control plane of streaming frames to browsers — WebRTC
`negotiate`, `abr` adaptive bitrate, `sfu` forwarding, `latency` budgeting,
`input` transport, `room`s, and `fleet` scaling. The media transport and
hardware `encoder` are fail-loud `NotConfigured` seams, not fabricated media.

### @neith/oss-prediction

Client prediction, rollback, and interpolation (Rust,
`libs/neith/oss-prediction`, phase 159.7): a deterministic `fixed`-point `sim`
underpins `predict`+reconcile (resimulating unacked inputs), GGPO-style
`rollback` and lockstep, and `interp`olation with bounded extrapolation and
lag-compensated hitscan — the netcode-feel layer.

### @neith/oss-presence

Presence, stats, leaderboards, and progression (Rust, `libs/neith/oss-presence`,
phase 159.10): rich `presence` cards, a typed `stats` store with aggregation,
`leaderboard`s, `achievements` and `quests`, `cloudsave` and `inventory` models.
Native trophy push and EOS/Steam/PSN/Xbox `federation` lookups are fail-loud
`NotConfigured` seams.

### @neith/oss-replay

Replay and spectator plane (Rust, `libs/neith/oss-replay`, phase 159.11): a
CRC32-framed on-disk `container` for the replication stream, keyframe-indexed
`playback` with reverse/fast-forward, a 6-DOF spectator `camera`, a `director`
feed, `killcam` extraction, and `compress`ion — only the cloud `upload` is an
external fail-loud seam.

### @neith/oss-replication

Iris-class replication graph and protocol (Rust, `libs/neith/oss-replication`,
phase 159.5): static/dynamic `net_id` GUIDs, a `ReplicationWorld` `entity` model
with authority transfer and dormancy, a build-time `property` RepLayout with
conditions, delta `quantize` compression, `fast_array` serializers, spatial
`graph` prioritisation, and `channel` streams — the minimal per-connection byte
stream that keeps clients converged.

### @neith/oss-rpc

RPC plane of the online subsystem (Rust, `libs/neith/oss-rpc`, phase 159.6):
transport-agnostic `descriptor`s (direction, reliability class, owner scope,
versions), server-authoritative `dispatch` admission with mandatory validation,
per-caller `ratelimit` token buckets, call `batch`ing and `compress`ion, and
`metrics`.

### @neith/oss-session

Session and game-server lifecycle (Rust, `libs/neith/oss-session`, phase 159.4):
a `session` state machine with legal transitions only, a best-fit bin-packing
`allocator` onto dedicated fleets, an Agones-class `fleet` autoscaler, host
`migration`, `p2p` listen-server support, `ban` lists, and `slots` reservation —
network-free policy and math.

### @neith/oss-testing

Cross-crate conformance suite for the fifteen OSS crates (Rust,
`libs/neith/oss-testing`, phase 159.15) — an integration harness with no mocks
of the systems under test: a 128-player replication `soak`, cross-`region` RTT
budgets, 10% packet-`loss` resilience, a `nat` connectivity matrix, 100k-tick
rollback `determinism`, protocol `fuzz`ing, and host-`failover`/`migration`
drills.

### @neith/oss-transport

Transport, NAT traversal, and security floor (Rust, `libs/neith/oss-transport`,
phase 159.8): ENet/Gaffer-style UDP `reliability` (ack-bitfield, retransmission,
channels), WebRTC/QUIC framing in `transports`, `stun`/`nat` traversal,
`congestion` control, `fec`, `mtu` discovery, `pacing`/`shaping`, and packet
`security` — protocol implementations verified against published test vectors.

### @neith/oss-voice

Voice chat and proximity audio (Rust, `libs/neith/oss-voice`, phase 159.9):
congestion-aware `codec` bitrate adaptation and RTP-style packetisation (the
native Opus encode/decode itself is a fail-loud seam), 3D `spatial` attenuation
with cone directivity, team/party `channel` routing with mute and block,
hysteretic `vad` + push-to-talk, and `caption`/`moderation` hooks.

### @neith/parity171-testing

Cross-crate validation suite for the 26 phase-171 UE/Blender parity crates
(Rust, `libs/neith/parity171-testing`) — a testing crate whose integration tests
live in lib.rs/tests: Verse sandbox, LWC planet scale, MegaLights 1000-light
convergence, RVT paging soak, the complete 200+ node Geometry Script corpus, and
motion-matching RMSE. The explicit `blender-reference` target renders a
canonical scene in headless Blender and grades extended Freestyle output with a
line-aware visual diff. Deterministic Project Obsidian dogfood binds Phase 27
set authoring, Phase 79 landmass/water, Phase 162 hero validation, and Phase 163
content-addressed ordered-shoot grading without claiming live-volume
certification from synthetic evidence.

### @neith/profiler-asset

Asset and cook profiler (Rust, `libs/neith/profiler-asset`, phase 160.11):
per-asset `cook` timing statistics, a weighted `buildgraph` with longest-path
critical-path analysis, a `depgraph` with three-colour DFS cycle detection, DDC
`cache` correlation (the remote cache is an `UnconfiguredRemoteCache` fail-loud
seam), `diskio`, `shader` and `sizedelta` tracking.

### @neith/profiler-audio

Audio-engine profiler (Rust, `libs/neith/profiler-audio`, phase 160.10):
active-`voices` tracking with priority stealing, per-bus `dsp_bus` budget
roll-ups, `plugins` CPU accounting (the out-of-process plugin host is a
fail-loud trait seam), `underrun` logs, `latency` metering, a `flamegraph`, and
stutter `correlate`ion — Wwise/FMOD Advanced-Profiler territory.

### @neith/profiler-capture

Tracing backend of the frame-profiler stack (Rust,
`libs/neith/profiler-capture`, phase 160.1): instrumented `scope`s via a
`neith_profile_scope!` macro with zero-overhead compile-out, per-thread
lock-free `ring` buffers, GPU timestamp zones, a monotonic `clock`, and a
versioned CRC-checked binary `format` a viewer can open, `stream`, or `replay` —
Tracy/Unreal-Insights capture-side parity.

### @neith/profiler-crash

GPU crash / post-mortem analyzer (Rust, `libs/neith/profiler-crash`, phase
160.13): a `minidump` model with CRC binary `codec` (the vendor capture source
is the one external seam), `tdr` timeout analysis, `memguard` guard-page fault
classification, `deadlock` and `watchdog` hang detection, `cmdbuffer` culprit
localisation, and an uploadable report `bundle` — Nsight-Aftermath/DRED
territory, CPU-only.

### @neith/profiler-gpu

GPU frame debugger (Rust, `libs/neith/profiler-gpu`, phase 160.3): a CPU-only
reimplementation of the RenderDoc/PIX data models — frame `capture` and replay
of an API-call stream, `state`/`texture`/`buffer`/`shader` inspection with a
`shadervm` interpreter, overdraw in `pixel`/`raster`, `barrier` analysis, and
raytracing `accel` structures. The only external boundary is a live devkit
socket, a fail-loud seam in `remote`.

### @neith/profiler-memory

Memory profiler (Rust, `libs/neith/profiler-memory`, phase 160.4): an LLM-style
hierarchical `tag_tree`, an allocation `timeline`, a `fragmentation` model with
first/best-fit allocators, a callstack-hash `leak` detector, retained-size
analysis, `oom_warning` projection, and `snapshot_diff` — the live cook-daemon
socket in `pipeline` is the only fail-loud seam.

### @neith/profiler-net

Network profiler (Rust, `libs/neith/profiler-net`, phase 160.5): Unreal Insights
Networking parity in pure Rust — per-connection `bandwidth` timelines,
`replication` byte attribution per (actor class, property), `rpc` frequency/size
stats, `packet` and `ack` analysis, `congestion` and `prediction` views — all
over caller-supplied deterministic inputs.

### @neith/profiler-physics

Physics-solver profiler (Rust, `libs/neith/profiler-physics`, phase 160.9):
broad/narrow `phases` timing with a real sweep-and-prune broad-phase, a
Projected-Gauss-Seidel `solver` with convergence iteration counts, `contacts`
timelines with Welford stats, `islands` and `sleeping` tracking, `substep`
accounting, and `determinism` checks — PhysX-PVD/Chaos-Insights territory.

### @neith/profiler-sample

Sample-based statistical profiler (Rust, `libs/neith/profiler-sample`, phase
160.7): a continuous `sampler` building an arena `CallTree` with self/total
counts, `symbol`ication, `cohort`/`population` aggregation across captures,
`regression` and `bootstrap` confidence statistics, and `trend` analysis — the
live kernel tracer is the only fail-loud seam.

### @neith/profiler-shader

Shader profiler and static analyser (Rust, `libs/neith/profiler-shader`, phase
160.8): a small real shader `il` in three-address form, a `cost` analyser with a
per-opcode latency/throughput table, `occupancy` and `registers` pressure
modelling, hardware `counters` aggregation with bottleneck classification,
`permutation`/`variants` analysis, and cross- `targets` diffing —
RGA/Mali-offline-compiler territory.

### @neith/profiler-stat

In-game stat-command and HUD overlay engine (Rust, `libs/neith/profiler-stat`,
phase 160.6): `stat unit`/fps/scene `frame` breakdowns, a scrolling `graph`,
`hitch` detection, colour-coded thread `bars`, a developer-`console` command
dispatcher, and `input` key-binding toggles — every overlay produced as data
(draw lists, layout rects); pixel readback is a fail-loud `FrameGrabber` seam.

### @neith/profiler-testing

Cross-crate validation suite for the profiler stack (Rust,
`libs/neith/profiler-testing`, phase 160.14) — a testing crate running against
the real crates: instrumentation `overhead` ≤3%, trace-open `fileio` throughput,
GPU capture `fidelity` and shader-stepping accuracy, loopback `stream_test`, and
a `report` matrix stating honestly which gates need external hardware or
multi-hour soaks.

### @neith/profiler-timing

Timing/flamegraph analysis (Rust, `libs/neith/profiler-timing`, phase 160.2):
reads a captured `Trace` and rebuilds nested `zones`, thread swim-lane
`timeline`s with ns-to-session zoom, bottom-up/top-down `calltree` flamegraphs,
`frames` deltas, task-graph `tasks`, and `concurrency` views — the analysis half
of the capture crate.

### @neith/profiler-ui

Profiler UI and workflow layer (Rust, `libs/neith/profiler-ui`, phase 160.12):
no windowing — every module produces the data a front-end renders: a dock
`layout` with a real min/weight constraint solver, a web-viewer `scene` graph to
z-ordered draw lists, a versioned remote-trace `stream` protocol, capture
`compare` deltas, `query` hit-testing, `export`, and `palette`/ `theme` systems.

### @neith/sculpt-brushes

Sculpt brush library (Rust, `libs/neith/sculpt-brushes`, phase 170.4): the
ZBrush/Blender/Mudbox brush set as real per-vertex deformation and
mesh-generation operators on `neith-sculpt-core` — `base` draw/clay/crease/
inflate/pinch family, `grab`/`snake_curve`/`transpose`, `claybuildup`, `cloth`
and `pose` brushes, `zsphere` armatures, `zremesher`-style remesh brush,
`nanomesh`, and `stamp`/`spotlight` projection.

### @neith/sculpt-core

Sculpt-mode foundation (Rust, `libs/neith/sculpt-core`, phase 170.1): the shared
substrate for all sculpt/NPR crates — an editable indexed `mesh` with adjacency,
a per-object sculpt `mode` session with per-face hiding, a pressure/tilt
`stroke` engine with lazy-mouse `stabiliser`, X/Y/Z + radial `symmetry`, an
additive/subtractive clay `compositor`, `falloff` curves, `undo`, and `vr`
input.

### @neith/sculpt-export

Sculpt export engine (Rust, `libs/neith/sculpt-export`, phase 170.9):
`gameready` low-poly + normal-map bundles, real text-format writers in `formats`
(OBJ, PLY, ASCII STL, glTF 2.0 with base64 buffers, ASCII USD, ASCII FBX),
`print3d` STL/3MF with a ray-cast wall-thickness check, `normalspace`
conversion, `udim` splitting, and engine `preset`s — the Alembic Ogawa binary
backend is an honest fail-loud seam in `exporter`.

### @neith/sculpt-face-sets

Face-sets / poly-groups engine (Rust, `libs/neith/sculpt-face-sets`, phase
170.5): per-face `sets` with grow/shrink/invert/isolate over edge `adjacency`,
auto-`assign` by normal angle/material/mask/UV island, a `paint` brush,
inter-set `boundary` visualisation, face-set↔vertex-mask `convert`, and per-set
`pivot`s.

### @neith/sculpt-layers

Non-destructive sculpt layers (Rust, `libs/neith/sculpt-layers`, phase 170.3): a
per-object displacement `layer` stack with visibility/opacity and
add/multiply/overlay blend modes, per-layer `mask` painting, `sublayer`s scoped
to a multires level, `morph`-target export, per-layer `version` history with
revert, and opacity `keyframe` animation.

### @neith/sculpt-mask

Sculpt masking engine (Rust, `libs/neith/sculpt-mask`, phase 170.6): a
per-vertex `mask` with falloff painting, box/lasso/line `shapes`, procedural
`generate` masks by cavity/AO/curvature, projected-image `texture` masks,
nearest-mirror `symmetry`, feather/smooth/sharpen `filter`ing, and masked-region
`extract`ion to a new mesh.

### @neith/sculpt-polypaint

Polypaint / vertex-colour engine (Rust, `libs/neith/sculpt-polypaint`, phase
170.7): per-vertex RGBA `paint` with pressure and pattern brushes, a `picker`
eye-dropper, an `hsv` hue-shift adjustment brush, `procedural`
colour-by-cavity/AO, and bidirectional vertex-colour↔texture `bake` over UVs.

### @neith/sculpt-retopo

Retopology engine (Rust, `libs/neith/sculpt-retopo`, phase 170.8): `manual`
poly-by-poly retopo with surface snapping via closest-point `project`ion, `auto`
instant-quad and cross-field flow-guided retopo, mirror-weld `symmetric` retopo,
`uvpack` island packing, high-to-low `shrinkwrap`, and normal/colour/skin-weight
`transfer` plus a texture `bake`r.

### @neith/sculpt-testing

Testing and validation for the sculpt + NPR pipeline (Rust,
`libs/neith/sculpt-testing`, phase 170.13) — a validation crate: large-mesh
`perf` throughput, dyntopo `burnin`, `multires_bake` accuracy against an
analytic reference, `faceset_roundtrip` serialisation, a retopo/map-bake
`corpus`, Freestyle `line_stability` across an animated camera, and a fail-loud
`.ztl` binary-import seam in `ztl`.

### @neith/sculpt-topology

Dynamic topology and multiresolution (Rust, `libs/neith/sculpt-topology`, phase
170.2): Sculptris-Pro `dyntopo` tessellation with a detail-size slider,
quadric-error `decimate` to a target count, Loop `subdiv` `multires` with
per-level displacement, `voxel_remesh` (DynaMesh-style surface nets),
cross-`field_remesh` (ZRemesher-style), and `crease`/`snapshot` support.

### @neith/shotops

Studio shot tracking and pipeline operations (Rust, `libs/neith/shotops`, phase
135.11): a 20-module ShotGrid-class core — production `hierarchy` and `workflow`
state, a `review_player` with `notes` and `share_link`s,
`assignment`/`vendor`/`turnover` management, `dependency` tracking,
`time_tracking`/`cost`/`forecast`, an `api` surface, and
`dcc`/`ingest_validator` hooks.

### @neith/silhouette

Roto, planar tracking, and paint core (Rust, `libs/neith/silhouette`, phase
135.3): a 29-module Silhouette/Mocha-class crate — `planar` tracking with
`point_tracker`s and `multi_planar` surfaces, roto with `feather` and
`auto_roto`, `optical_flow`, `clean_plate`/`content_fill`/`wire_remove` paint,
`screen_replace`, `stereo` workflows, and `deflicker`/`grain` finishing.

### @neith/sim-cloth

XPBD cloth and soft-body kernel (Rust, `libs/neith/sim-cloth`, phase 157.6): an
`xpbd` distance-constraint solver with per-substep compliance, dihedral
`bending`, strain-threshold `tearing` with topology splitting, spatial-hash
`self_collision`, analytic-SDF `body_contact`, `aero`dynamics, `garment`
assembly with `stitch` seams, and a co-rotational `fem` soft-body path.

### @neith/sim-core

Shared foundation of the phase-157 Mantaflow/Houdini-class simulation framework
(Rust, `libs/neith/sim-core`): `math` with polar decomposition, a `domain` box
with nested multi-res, dense `grid`s + staggered `MacGrid`, a sovereign
VDB-class `sparse` grid, narrow-band `levelset`s, seeded `rng`, and
`bake`/`cache` machinery every solver crate reuses.

### @neith/sim-farm

Distributed simulation orchestration (Rust, `libs/neith/sim-farm`, phase 157.13)
— the planning/scheduling layer, not a live farm: shot `decompose` across
machines and MPI-rank domain carving, `scaling` prediction, dependency
`schedule` ordering, farm `submit` descriptors, `retry` policies, `proxy` review
gating, `cost` estimation, and byte-budget `cache_policy` — real cluster
hardware is explicitly out of scope.

### @neith/sim-forces

Force fields and object interaction (Rust, `libs/neith/sim-forces`, phase
157.10): static/kinematic/deforming `obstacle`s as SDF + cell-type masks with
moving-surface velocity stamping, triangle-mesh-to-SDF in `collider`, `flow`
inflow/outflow, curve `guide` forces, curl `noise`, and `region` masks — all on
the shared sim-core grid types.

### @neith/sim-games

Real-time baking for game runtimes (Rust, `libs/neith/sim-games`, phase 157.12):
bakes solved sims into runtime-samplable assets — `flipbook` atlases, volume
`texture`s, `vat` vertex-animation textures, `pointcache`s, GPU `particle_seed`
textures, `loopbake` cycles, and `impostor`s — every baker has a tested decode
inverse within stated tolerance.

### @neith/sim-gas

Eulerian pyro/gas solver (Rust, `libs/neith/sim-gas`, phase 157.3): a
staggered-grid smoke and fire solver — semi-Lagrangian + MacCormack/BFECC
`advect`ion, deflated-PCG `pressure` projection, `vorticity` confinement,
two-scale `upres`, fuel→flame→smoke `combustion`, and Planck `blackbody` fire
emission — Houdini-Pyro/EmberGen territory, offline quality.

### @neith/sim-liquid

FLIP/APIC/PIC liquid solver (Rust, `libs/neith/sim-liquid`, phase 157.2): a
hybrid particle-grid incompressible solver — PIC/FLIP/APIC/MLS `transfer`,
MIC(0)-preconditioned PCG `pressure` projection, level-set `surface` with CSF
tension and adaptive seeding, Newtonian/Herschel-Bulkley `rheology`,
`whitewater`, and a `pbf` quick-preview path.

### @neith/sim-mpm

Material-point-method solver (Rust, `libs/neith/sim-mpm`, phase 157.4): one
MLS-MPM `solver` running snow, sand, goo and elastic solids by swapping the
`material` constitutive law and plastic return-map — signed 3x3 `svd`, quadratic
B-spline `grid` transfer, `fracture`, and solver `coupling`.

### @neith/sim-ocean

Ocean, waves, and whitecaps (Rust, `libs/neith/sim-ocean`, phase 157.8): a
Tessendorf Phillips-`spectrum` `fft_ocean` with choppiness, Jacobian foam and
seamless tiling, analytic `gerstner` trochoids, `beaufort` wind presets,
Green's-law `shore` shoaling and breaking, `shallow_water` solve, and boat
`wake`s.

### @neith/sim-particles

Particle system / POPs solver (Rust, `libs/neith/sim-particles`, phase 157.5): a
structure-of-arrays `particle` store, point/surface/volume/curve `emitter`s with
deterministic seeding, `forces` and `collision`, `boids` flocking,
`poisson`-disk sampling, `spatial` hashing and a `bvh`, `metaball`/`mesh`
outputs, and a `gpu` descriptor path — property-tested against conservation laws
and analytic solutions.

### @neith/sim-render

CPU reference volume renderer (Rust, `libs/neith/sim-render`, phase 157.11) —
deliberately not a GPU pipeline: a physically-based `volume` ray-marcher serving
as ground truth for the viewport, with `aov` channel extraction from
dense/staggered/sparse grids, `blackbody` emission, `phase` functions,
`denoise`, and `image` output.

### @neith/sim-rigid

Rigid-body, constraint, and fracture solver (Rust, `libs/neith/sim-rigid`, phase
157.7): a sequential-impulse `solver` with contact manifolds, restitution and
Coulomb friction, hinge/ball/slider/cone-twist `constraint` joints as real
Jacobian impulses, force-limited `motor`s and CFM/ERP springs, `voronoi`
pre-fracture by half-space clipping, `island` sleeping, and `building`
demolition clustering.

### @neith/sim-surface

Surface reconstruction and meshing (Rust, `libs/neith/sim-surface`, phase
157.9): Yu-Turk `anisotropic` kernel fields from particles, canonical 256-case
`marching_cubes` and QEF `dual_contour`ing, `narrowband` polygonisation,
`smoothing`/`subdivision`/`remesh` post-passes, `uv` generation, and
`velocity`-mapped `meshcache` output.

### @neith/sim-validation

End-to-end validation benchmarks for the simulation framework (Rust,
`libs/neith/sim-validation`, phase 157.14) — a testing crate asserting physical
invariants, not screenshots: `dambreak` vs the Ritter analytic solution, a
rising `bubble`, Rayleigh-Taylor/Kelvin-Helmholtz `instability`, an
`mpm_snowball`, a `pyro_corpus`, and `.bobj`/sparse-cache `interop` round-trips.

### @neith/spatial-anchors-collab

Multi-user collocated sessions (Rust, `libs/neith/spatial-anchors-collab`, phase
166.9): LAN peer `discovery` with heartbeat expiry and cloud-relay fallback, a
sequence-ordered shared-anchor `protocol` with latency budgeting, chunked
`roomscan` sharing, a last-writer-wins `crdt` with vector clocks for shared
scene state, and `session` `recording` — peer-to-peer, no central authority.

### @neith/spatial-audio

Spatial-audio engine of the spatial runtime (Rust, `libs/neith/spatial-audio`,
phase 166.7): `hrtf` binaural rendering via Woodworth ITD + ILD + head-shadow
low-pass, `room` acoustics from the scene mesh with the Sabine RT60 equation,
`occlusion` filtering, first-order `ambisonics` encode/decode/rotate, and a
`spatializer` — closed-form and deterministic for headless conformance runs.

### @neith/spatial-avatars

Avatar and presence layer (Rust, `libs/neith/spatial-avatars`, phase 166.4):
`persona` face+voice signature capture with cosine verification, a
joint-hierarchy `rig` with stylised variants and slot-conflict wardrobe,
quantised gaze/`expression` frame streaming, energy+formant mic lip-sync in
`audio`, two-bone law-of-cosines upper-`body` IK, and `privacy` controls.

### @neith/spatial-conformance

Cross-crate conformance for the spatial runtime (Rust,
`libs/neith/spatial-conformance`, phase 166.11) — a validation crate driving the
real sibling implementations: motion-to-photon `latency` (≤12 ms after
reprojection), eye-tracking `calibration` (≤1 degree), hand `jitter` benchmarks,
room `mesh_accuracy` across synthetic rooms, `thermal` throttle monotonicity,
anchor `drift` bounds, and `wcag` checks, plus fail-loud `external` gates for
on-device targets.

### @neith/spatial-core

Session, scene, and world-anchor foundation of the spatial runtime (Rust,
`libs/neith/spatial-core`, phase 166.1): a cold-start/warm-resume `session`
state machine, persistent `anchor`s with `cloud_anchor` relocalisation via
Horn's rigid `registration`, scene-`mesh` reconstruction and occlusion, semantic
room `segmentation`, spherical-harmonic `lighting` estimation with CCT,
plane/image/object `targets`, `geospatial`/`vps` positioning, and `privacy`
gating — ARKit/ARCore/Quest-Scene territory.

### @neith/spatial-input

Gaze, hand, voice, and accessibility input (Rust, `libs/neith/spatial-input`,
phase 166.3): an eye-tracking `gaze` ray with dwell hover, a 27-joint `hands`
skeleton with pinch/curl features, `gestures` (gaze+pinch, two-hand
scale/rotate, pose recognition, custom recognisers), `voice` wake-word and
command grammar, `touch`/`controller`/`keyboard` paths, and `accessibility`
input.

### @neith/spatial-os

Spatial-OS integration shell (Rust, `libs/neith/spatial-os`, phase 166.10): a
3D-volume `window_manager` with focus, z-order and side-by-side multitasking, a
home `launcher` grid with app install store, system-vs-app `gestures` routing,
yaw recentering and `space` reset with guardian boundary breach fade,
`accessibility` settings, and a typed 2D↔3D `clipboard` — integrating with the
phase-45 sovereign OS `shell`.

### @neith/spatial-physics

Physics-in-passthrough (Rust, `libs/neith/spatial-physics`, phase 166.6):
virtual rigid bodies colliding with the reconstructed room — sphere-vs-scene
`collision` with safety-zone clamping, gravity-aligned `dynamics` with
support-polygon topple detection and hand-push impulses, planar contact
`shadow`s with dynamic occluders, real-light-driven Lambert/Blinn `shading`, and
surface `magnet` snapping.

### @neith/spatial-render

Stereoscopic and foveated XR render layer (Rust, `libs/neith/spatial-render`,
phase 166.5): per-eye `stereo` view/projection with IPD calibration and depth
late-latching, fixed + eye-tracked `foveation` with variable-rate shading tiles,
asynchronous timewarp/spacewarp `reprojection`, `power`-aware refresh/resolution
downshift, lens `distortion`, and `hdr` passthrough compositing.

### @neith/spatial-sdk

Developer SDK and tooling for the spatial runtime (Rust,
`libs/neith/spatial-sdk`, phase 166.8): C-ABI `bindings` descriptors with a
generational opaque-handle table, Unity/Unreal/Godot `plugins` manifests, WebXR
capability translation, an imperative `scenegraph` with world-transform
composition, Reality-Composer-class `authoring`, a `simulator` model,
`debug_perf` tooling, and `deeplink`s.

### @neith/spatial-volumes

Volumes and immersive/shared spaces (Rust, `libs/neith/spatial-volumes`, phase
166.2): bounded `volume`s with content clipping and auto-resize-to- room,
`immersive` full-space takeover with a progressive-immersion dial, multi-app
`shared_space` compositing via guillotine packing, `passthrough` blend with
privacy masking, `portal`s, and a `spectator` view.

### @neith/storyboard

Storyboarding and pre-production core (Rust, `libs/neith/storyboard`, phase
135.10): a 38-module crate spanning panel `drawing` and `timeline` animatics,
`camera_move` and `previs_scene` with lens and `sun_sky`, screenwriting
(`fountain`, `fdx`, dual dialogue), and production management —
`breakdown_sheet`, `stripboard`, `shooting_schedule`, `call_sheet`, `budget`,
and `union_payroll`.

### @neith/subs

Subtitle, caption, translation, and dubbing core (Rust, `libs/neith/subs`, phase
135.8): a 34-module crate covering text/XML/legacy formats plus
`cea608`/`cea708`, timing QC (`reading_speed`, `line_break`, `waveform_sync`),
`sdh` and forced narrative, `translation_memory` and `machine_translation`
workflow models, and a dubbing plane (`lip_sync`, `rhythmo_band`, `me_track`,
`dub_monitor`).

### @neith/vfx-attribute

Particle attribute substrate of the phase-161 Niagara-class VFX stack (Rust,
`libs/neith/vfx-attribute`): structure-of-arrays `storage` with std430 `layout`
sizing, `half`/unorm8/snorm8 compression codecs, typed `attribute`s with spawn
defaults and persistence policy, stable `builtin` semantics for addressing
streams by role, `material` bindings, and a runtime `inspector`.

### @neith/vfx-core

Effect asset model of the VFX stack (Rust, `libs/neith/vfx-core`, phase 161.1):
an `EffectSystem` of `emitter`s with ordered `module_stack`s, behaviour authored
as a typed dataflow `graph` that `compile`s to both a CPU interpreter and a WGSL
compute module, a gameplay-bindable `blackboard`, a `timeline` of triggers, a
versioned `schema` envelope, and hot-reload dependency tracking.

### @neith/vfx-data-interfaces

External data plug-ins for VFX graphs (Rust, `libs/neith/vfx-data-interfaces`,
phase 161.7): per-particle samplers over injected data — `mesh`/`skeletal`
surface sampling, `sdf`, `texture`, `physics`, `navmesh`, `audio` FFT and
`beat`, `gbuffer` depth/normal, `curve` LUTs, and `neural` — all behind the
`DataInterface` contract with an honest `Availability` seam that reports
unavailable rather than feeding zeros.

### @neith/vfx-editor

Authoring-editor model layer (Rust, `libs/neith/vfx-editor`, phase 161.8) — data
structures a UI binds to, no pixels of its own: a `graph_editor` with validated
edits, a reflected `property_panel`, a keyframe `timeline` with real curve
evaluation, a preview `transport`, debounced `recompile`, a debug `hud` with
`breakpoint`s and a particle `inspector`, undo/redo `history`, and a
vector-clock CRDT `collab` layer.

### @neith/vfx-library

Shipped VFX preset catalogue (Rust, `libs/neith/vfx-library`, phase 161.10):
every preset is a real `builder` composing a validate()-passing `EffectSystem` —
`combat` (muzzle flashes as sub-frame emissive cone bursts), `magic`, `weather`
(8192-particle box-volume rain), `environment`, `vehicle`, `scifi`, `horror`,
`npr`, and `educational` categories in a `registry`.

### @neith/vfx-modules

Behaviour-module library (Rust, `libs/neith/vfx-modules`, phase 161.4): each
`Module` is a pure deterministic transform over a particle pool for one timestep
— `motion` (symplectic integration, inverse-square fields, analytic curl
`noise`), `appearance`, `collision`/`env`ironment response, and `event`
recording onto an `EventBus` — real domain maths, not data plumbing.

### @neith/vfx-perf

Performance, LOD, and budgeting governor (Rust, `libs/neith/vfx-perf`, phase
161.9): piecewise-linear `lod` curves, `frustum` and `occlusion` culling, a
global GPU-ms/VRAM `budget` with priorities, particle `pool`ing, `warmup`
pre-simulation, `async_graph` compute hooks, `multigpu` splitting, and platform
`profile` clamping of real effect systems.

### @neith/vfx-renderers

Render primitives of the VFX stack (Rust, `libs/neith/vfx-renderers`, phase
161.5): turns live particle pools into GPU-ready geometry with the real WGSL a
wgpu pipeline would bind — billboard `sprite`s, `mesh_instance` TRS buffers,
Catmull-Rom `ribbon`s and `strand`s, `beam`s, `light` parameters, oriented
`decal` projectors, view-aligned `volume` slices, and marching-cubes
`metaball`s.

### @neith/vfx-sim

Advanced simulation stages (Rust, `libs/neith/vfx-sim`, phase 161.6): correct
CPU references of the compute-shader building blocks, with real WGSL emitted
alongside — a topologically-scheduled `stage_graph` with barrier checking, grid
`fluid` and dynamic `sdf` field generators, `neighbour` hash-grid search,
`sort`/`scan` primitives, `indirect` dispatch, `pingpong` buffers, and `ml`
inference.

### @neith/vfx-spawn

Spawn rules and emission (Rust, `libs/neith/vfx-spawn`, phase 161.2):
`burst`/`rate`/`shape`/`skeletal`/`beam`/`curve`/`event`/GPU-`readback` emitters
producing `SpawnRequest`s written into the particle pool, seeded PCG32 `streams`
for bit-reproducible effects, spawn `budget`s and `throttle`s, and typed
`SpawnError` refusal of invalid geometry or budgets.

### @neith/vfx-testing

Validation harnesses for the VFX stack (Rust, `libs/neith/vfx-testing`, phase
161.11) — a testing crate driving the real sibling crates: a `stress` CPU
sim-throughput harness for the 1M@60/5M@30 targets (the GPU frame-rate
acceptance itself is hardware-gated and reported honestly as CPU throughput),
cross-run `determinism`, `lod_smoothness`, and `budget_cap` enforcement.

### @neith/virtualprod

LED volume, camera tracking, ICVFX, and motion control (Rust,
`libs/neith/virtualprod`, phase 135.13): a 36-module crate spanning
`render_cluster`/`genlock`/`timecode` sync, `frustum` and `tracked_camera`
ICVFX, tracker protocol models (`mosys`, `redspy`, `optitrack`, `freed`),
`lens_encoder` metadata, `light_card`/`color_matching` wall tools, and
`rig_control` motion-control playback with `take_repeatability`.

### @neith/vp-broadcast

Broadcast virtual studio (Rust, `libs/neith/vp-broadcast`, phase 163.9):
real-time `graphics` lower-thirds, a virtual `setlib` with camera presets, the
phase-162 talent-`avatar` binding (a fail-loud rig seam), `ar_bridge`
depth-ordered AR-over-key compositing, `datagraphics`, a multi-camera
`director`, instant-`replay` speed ramps, and an NDI/SDI/ST-2110 `output` model
— Vizrt/Brainstorm territory.

### @neith/vp-camera

Camera tracking and metadata (Rust, `libs/neith/vp-camera`, phase 163.3):
timestamped confidence-weighted `TrackerSample`s, `ingest` normalisation for
RedSpy/Ncam/StarTracker/OptiTrack conventions (the live tracker is a fail-loud
`TrackerSource` seam), `lens_encoder` calibration, `imu` fusion,
`freed`/`rttrpm`/`osc` parsers, `prediction`/smoothing, and timecode-aligned
`record`ing.

### @neith/vp-cluster

Multi-node render cluster (Rust, `libs/neith/vp-cluster`, phase 163.1): the
nDisplay/RenderStream-class brain keeping N nodes in lockstep — leader
`election`, config-driven `topology`, genlock `swaplock` frame sync, a PTP
deadline `scheduler`, `timecode_sync`, `heartbeat`/failover and crash `restart`
— all deterministic in-process logic; the OSC/gRPC wire is an honest `Transport`
seam that fails loud until bound.

### @neith/vp-color

On-set colour pipeline (Rust, `libs/neith/vp-color`, phase 163.5): an OCIO-
class `graph`, `aces` IDT/RRT/ODT chain, per-panel `panel_cal`ibration,
`camera_log` inversion (ARRI LogC, S-Log3, Log3G10, PQ, HLG — published curves),
wall→camera `roundtrip` verification with CIEDE2000, `cdl`/`lut` grading,
`colorchecker` auto-match, `metamerism` alerts, and per-setup `signoff`.

### @neith/vp-control

Operator control surface (Rust, `libs/neith/vp-control`, phase 163.8) — a
deliberately GUI-free headless state model a web/tablet client and hardware
`panel` both drive: a serialisable `surface` aggregate, scene/shot/take
`selector`s, live parameter `dials`, a `cue` engine with fades, role dashboards
in `roles`, emergency wall-black `safety`, and `snapshot` autosave with
rehearsal/record/playback `mode`s.

### @neith/vp-core

Shared spine of the phase-163 virtual-production stack (Rust,
`libs/neith/vp-core`): dependency-free `math` (Vec/Mat/Quat, Ray/Plane/
Frustum), drop-frame-correct SMPTE `timecode` with PTP and genlock phase,
`color` science (CIE chromaticity, Lab, ΔE76/ΔE2000), a `camera`
intrinsics/extrinsics/distortion model, and typed `ids` — every vp-\* crate
builds on this vocabulary.

### @neith/vp-frustum

Inner/outer frustum rendering (Rust, `libs/neith/vp-frustum`, phase 163.4): the
ICVFX heart — a generalized Kooima off-axis perspective through the LED
`screen`, the camera-accurate `inner` parallax window with overshoot margin,
`outer` ambient fill with set-extension bypass, soft-edge `blend` and
multi-camera crossfade, `colormatch`, a latency `meter`, and `hero`-frame
extraction.

### @neith/vp-mr

In-camera VFX, green screen, and mixed reality (Rust, `libs/neith/vp-mr`, phase
163.7): colour-difference and chroma-distance `keyer`s, premultiplied
Porter-Duff `composite` with depth test, `despill`, set `extension`, `occluder`
masking, LiDAR `depth` compositing, `reflection`/`lighting` matching, a `shadow`
catcher, and `roto` assist — real signal/compositing maths on the vp-core
primitives.

### @neith/vp-pipeline

Editorial and VFX handoff (Rust, `libs/neith/vp-pipeline`, phase 163.11):
CMX3600 `edl` + OTIO export, per-take `usd` (USDA) scene publish, a
timecode-keyed `camera_path`, EXR+JSON `plate` packages (clean vs graded), ASC
`cdl` persistence, proxy-`geometry` OBJ handoff, a post-`rebuild` manifest, and
a bidirectional DCC `livelink`.

### @neith/vp-record

Capture, recording, and playback (Rust, `libs/neith/vp-record`, phase 163.10):
raw `plate` capture with codec-modelled byte accounting, a timecode-keyed FreeD
`tracking` recorder with interpolated pose queries, a synchronised
multi-cam+audio `timeline` with out-of-sync flagging, a Take `recorder` state
machine, `retake`-less re-render, `dailies` packaging, and a `shotops` publish
hook.

### @neith/vp-scene

Virtual scene content pipeline (Rust, `libs/neith/vp-scene`, phase 163.6): a
`SceneAsset`/`SceneGraph` model with a real `gltf` 2.0 JSON parser (binary
containers fail loud via an `ExternalDecoderSeam`), spatial-grid `streaming`
with hysteresis, incremental `dcc_update` live-link edits, `sky`/time-of-day and
`hdri` domes, `weather`/`atmospherics` hooks, `splats`, and take `history` with
asset `bundle` shipment.

### @neith/vp-testing

Virtual-production validation harness (Rust, `libs/neith/vp-testing`, phase
163.12) — a testing crate grading traces against acceptance criteria: `genlock`
jitter ≤1 scan line, motion-to-photon `latency` ≤1.5 frames at 24 fps, `color`
round-trip ≤ΔE 1, per-node `throughput` (4K/120), multi-stage `isolation`,
mid-take `smoothness`, retake `determinism`, and `lens_compat` checks.

### @neith/vp-wall

LED volume geometry and mapping (Rust, `libs/neith/vp-wall`, phase 163.2): a
`panel` spec catalog, flat/curve/cylinder/ceiling/floor `wall` geometry, wall-UV
to panel pixel `mapping` with geometry-preserving `bezel` compensation, `warp` +
soft-edge blend, scan-based `calibration`, `moire` mitigation, `hdr` luminance
calibration, panel `health` monitoring, and a Brompton/Novastar/ROE `processor`
bridge model.

### @neith/vse-audio

Audio DSP layer of the embedded Video Sequence Editor (Rust,
`libs/neith/vse-audio`, phase 158.5): per-strip `gain_pan` with constant-power
pan, a bus `mixer`, RBJ EQ/compressor/limiter `dynamics`, BS.1770-4 `loudness`
metering with true peak, sidechain `ducking` under dialogue, spectral-flux
`beatgrid` tempo snapping, and `waveform` caching — the VST3/AU/LV2/CLAP
`plugin_host` scan is a fail-loud seam.

### @neith/vse-conform

Editorial conform and interchange (Rust, `libs/neith/vse-conform`, phase 158.9):
`otio` JSON import/export, an `aaf` object model with binary MS-CFB/OLE2
round-trip, `fcpxml` and Premiere `xmeml` round-trips, CMX-3600 `edl`, Resolve
XML, `sendto` handoffs to the compositor/colorist/2D-animation phases, and
auto-`conform` from an editorial cut with version-up.

### @neith/vse-core

Timeline and strip model of the VSE (Rust, `libs/neith/vse-core`, phase 158.1):
exact rational `time` with cross-rate rescale and SMPTE drop-frame timecode,
`strip` primitives with lock/mute/solo and meta-strips, animatable `keyframe`
property tracks, `edit` operations, `marker`s, `snap`, and `shuttle` — the
foundation every other vse-\* crate composes.

### @neith/vse-effects

Per-strip video effects (Rust, `libs/neith/vse-effects`, phase 158.4): every
operator implements the `Effect` trait over linear f32 RGBA `image`s in an
ordered `EffectStack`/`graph` — `color` levels/curves/balance, Reinhard/ACES
`tonemap` (with an OCIO view seam), chroma `key`, `mask`s, `retime`,
`stabilise`, `blur`/`grain`/`lut`, and `subtitles`/`text` keyed off the shared
rational clock.

### @neith/vse-ingest

Media ingest and proxy (Rust, `libs/neith/vse-ingest`, phase 158.2): probes
containers into timeline-ready strips — `media` and `metadata` (timecode,
reels), `proxy` encode command specs, `imageseq` and `renderlayer` detection,
waveform/proxy `cache`s, and VFR `conform` to a constant edit rate. Running
ffmpeg and debayering camera `raw` are typed fail-loud seams
(`ExecUnavailable`/`RawDecodeUnavailable`).

### @neith/vse-playback

Real-time playback engine of the VSE (Rust, `libs/neith/vse-playback`, phase
158.6): a byte-budgeted RAM+disk LRU frame `cache` keyed by (strip, frame,
quality), a look-ahead `prefetch` scheduler with a real worker thread, adaptive
`quality` under load, frame/field-exact `scrub`bing, and a `transport` —
hardware `decode`, SDI `output` and pro-audio backends are honest fail-loud
seams.

### @neith/vse-render

Render queue and output (Rust, `libs/neith/vse-render`, phase 158.7): turns a
timeline into shipped files — a JSON-persistable `preset` registry, a
`codec`/pixfmt model with ffmpeg encoder-arg builders, `range` and `stem`
selection, a render `queue` and `farm` model, `burnin`/`caption`/`hdr` handling,
and `upload`/`reingest` — live ffmpeg `exec`, farm schedulers and CDN endpoints
sit behind fail-loud seams.

### @neith/vse-review

Dailies and frame review (Rust, `libs/neith/vse-review`, phase 158.8):
timecode-anchored `notes` with drawable annotations, voice memos and CSV/PDF
export, reviewer `roles` and capabilities, a guarded per-shot `approval` state
machine with audit history, version `compare` with an A/B wipe slider, and
`shotops`/live-`session` sync payloads behind fail-loud transport seams.

### @neith/vse-storyboard

Storyboard/animatic mode for the VSE (Rust, `libs/neith/vse-storyboard`, phase
158.10): a `board` deck of still panels with per-panel timing and a script
column laid onto a core timeline, scratch-track `beat` alignment of panel
boundaries, auto-`slate` shot numbering, and `promote` handoffs into the
grease-pencil, storyboarding, and previs pipelines.

### @neith/vse-testing

Cross-crate validation suite for the VSE (Rust, `libs/neith/vse-testing`, phase
158.11) — a testing crate covering the locally-actionable slices of the
phase-158 matrix: `roundtrip` interchange fidelity (OTIO/AAF/FCPXML/EDL/
Premiere), `hdr` metadata preservation, sample-accurate `audio_phase` mixing, a
deterministic edit-storm `soak`, and `render_determinism` frame hashing.

### @neith/vse-transitions

Transitions and effects maths for the VSE (Rust, `libs/neith/vse-transitions`,
phase 158.3): dissolve `blend` curves, `wipe` patterns, `motion` pushes,
landmark-based `morph` cuts, `audio` cross-fades, `procedural` glitches,
`transform3d` flips, and automatic `cut` detection — all on normalised
resolution-independent inputs; the compositor feeds samples through these
functions.

### @neith/dcc-annotations

Editor annotation tool (Rust, `libs/neith/dcc-annotations`, phase 172.19):
freehand + text markup in any editor — 2D-screen and 3D-world `annotation`
layers with per-layer colour/thickness and leader-line `TextAnnotation`s, `snap`
to object/face/vertex, an `integration` module with Grease-Pencil conversion,
author-tagged layer merge and a dailies `ReviewSession` note workflow, and
SVG/PNG-raster/PDF `export`.

### @neith/dcc-color-attrs

Colour / vertex attributes, post-3.2 model (Rust, `libs/neith/dcc-color-attrs`,
phase 172.18): float4/byte4 `ColorAttribute`s on point/corner domains with
active-render/edit selectors on `Mesh`, a `bake` module (ray-traced AO,
Laplacian curvature, material), masked vertex `paint` with gradient/fill and
geometry-node field sampling, and `export` to glTF COLOR_0 / USD primvars /
Alembic plus legacy tessface migration.

### @neith/dcc-drivers

Driver system and relationship depth (Rust, `libs/neith/dcc-drivers`, phase
172.23): drivers bind typed `DriverVariable`s (single-property, rotational
difference, distance, transform channel) and reduce them via a sandboxed
recursive-descent `expr` evaluator; around that sit a `DriverGraph` with
dependency-cycle detection, batch `retarget`, a copy/paste `library` with
corrective-shape-key and face-rig presets, a `debug` value-watch + profiler +
errors panel, and a global `KillSwitch`.

### @neith/dcc-graph-editor

Graph Editor / F-curve depth (Rust, `libs/neith/dcc-graph-editor`, phase
172.22): `bezier` de Casteljau evaluation with an X-to-t inverse solver,
Auto/Vector/Free/Aligned/Auto-Clamped handles, the full Penner easing set in
`interp`, a `modifiers` stack (Noise/Cycle/Generator/Envelope/Limit/Stepped),
RDP-decimate/smooth/sample/bake `cleanup`, multi-channel `selection` with
normalised + proportional editing, key `clipboard`, snapping, and an `euler`
filter with quaternion dual-cover fix.

### @neith/dcc-multi-edit

Multi-object edit mode (Rust, `libs/neith/dcc-multi-edit`, phase 172.24): a
`MultiEditSession` over several `EditObject`s with unified vertex selection,
world-space transforms distributed through per-object local frames, per-object
pivot and mirror, `ops` propagation (extrude/inset/bevel and multi-object UV
unwrap), cross-object `snap`, and a combined atomic `UndoStack` boundary.

### @neith/dcc-outliner

Outliner + view layers + render passes (Rust, `libs/neith/dcc-outliner`, phase
172.20): a `SceneTree` collection/object arena flattened into filterable
`Outliner` rows with tree modes and isolate/solo, a `VisibilityTable` resolving
viewport/render/select/holdout through the hierarchy, drag-drop and batch-rename
`collection_ops` with orphan/fake-user purge, `ViewLayer` include/exclude with
material/light overrides, `passes` with exact channel layouts plus LPE and AOV
custom passes, and a `compositor` routing surface.

### @neith/dcc-pose

Pose-mode depth (Rust, `libs/neith/dcc-pose`, phase 172.26): `Armature` posing
with bone collections, a `PoseLibrary` with copy/paste, snap-to-rest and
cross-frame propagation, a quaternion-slerp `blend` pose blender and
breakdowner, `mirror` / paste-flipped via `.L`/`.R` name flipping, and FABRIK
auto-`ik` on bone chains.

### @neith/dcc-proportional

Proportional editing (Rust, `libs/neith/dcc-proportional`, phase 172.25): the
`O`-key smooth-falloff transform — eight `Falloff` shapes (Smooth/Sphere/Root/
Inverse-Square/Sharp/Linear/Random/Constant), connected-only mode via Dijkstra
`graph_distances` over the mesh graph, radius-controlled `apply_translation`,
`domains` application to UV/animation-channel/weight data, and a `RadiusOverlay`
visualisation circle.

### @neith/dcc-texture-paint

Texture-paint mode (Rust, `libs/neith/dcc-texture-paint`, phase 172.17):
painting onto UV-mapped texture `Canvas`es with UDIM tile routing in `UdimSet`,
falloff `Brush` dabs with tablet pressure/tilt (`Stylus`), mask and symmetry,
camera-view `projection` painting with stencil and clone brushes, smear/softener
`filters` plus cross-seam dilation, an OCIO-managed `LayerStack` with polypaint
baking, and `DirtyRegion` batching for GPU upload.

### @neith/dcc-timeline-markers

Timeline + pose + camera markers (Rust, `libs/neith/dcc-timeline-markers`, phase
172.21): coloured/labelled `Marker`s on a `MarkerTrack` with camera-marker
playback auto-switch and in-action `PoseMarker`s, `ops` for
drag/duplicate/group, filtering/search and cross-scene sync, `snap` with
BPM-to-frame beat grids, audio-beat import and BPM estimation, and
OpenTimelineIO marker `export_otio`.

### @neith/engine-cameras

Gameplay + cinematic cameras (Rust, `libs/neith/engine-cameras`, phase 172.5): a
physical `CineLens` (focal/aperture/filmback to FOV plus hyperfocal DOF) with a
`LensDatabase`, autofocus + rack-`focus` keyframes, `rig` behaviours
(follow/orbit/boom/POV/dolly), critically-damped `smooth_damp` + leash
`damping`, soft `collision` pull-back, thirds/headroom/look-room `composition`
with aim-assist, a `ShakeMixer` oscillator library, a multi-camera
`CameraDirector` with eased cut/blend, and a Cinemachine-class `CameraBrain`
vcam with a `LiveLinkFeed` bridge.

### @neith/engine-commonui

Common-UI depth (Rust, `libs/neith/engine-commonui`, phase 172.12): a
gamepad-first UI framework — D-pad/stick spatial `FocusRouter` over `Widget`
rects with gamepad/mouse/touch parity, a `ScreenStack` activation stack with
back-stack + breadcrumb, a platform input-`PromptLibrary` and virtual keyboard,
a localised `ActionBar` over `LocTable`s, hot-reloadable `Theme`s with
high-contrast/large-text `Accessibility` modes, pillarbox/safe-zone `layout`,
and modal/toast/drawer `OverlayManager` with screen-reader annotations.

### @neith/engine-concert

Concert multi-user editing (Rust, `libs/neith/engine-concert`, phase 172.7):
collaborative scene editing on convergent CRDTs — a Lamport `Clock`,
`LwwRegister` + add-wins `OrSet`, a transaction-based `Document`, a `Session` in
client-server or peer-to-peer topology, `presence`
(cursor/camera-follow/selection/ping/VR pose), roles + `Permissions`, a
`ChangeLog` with blame, persistence and replay, and a `ConflictDetector`. All
in-process models: the chat/voice `ChatBridge` is a message log + membership set
(no audio transport), and the `RemoteBridge` DCC/engine bridge is a
host-provided-transport seam that fails loud when disconnected.

### @neith/engine-data-registry

Data registry + data-driven CVars (Rust, `libs/neith/engine-data-registry`,
phase 172.13): a `DataRegistry` federating `LocalTable`/`RemoteFeed`/
`ComputeSource` data sources with `CompoundKey` lookup, an LRU + TTL
`RegistryCache` with revision invalidation, an `AsyncFetch` state machine, and a
`CVarSystem` of data-driven console variables with explorer search, a change
audit log and hot-reload. The remote feed is snapshot-fed from the LiveOps plane
and fails loud (`NotConfigured`) until a snapshot is applied — no network fetch
of its own.

### @neith/engine-dmx

DMX / Art-Net / sACN lighting control (Rust, `libs/neith/engine-dmx`, phase
172.6): a headless model + codec crate — a 512-channel `DmxUniverse` with
overlap-guarded patching, a `FixtureDefinition` library with 8/16-bit channels,
byte-exact `ArtDmx`/`ArtPoll` and `SacnDataPacket` E1.31 codecs, MIDI-to-DMX and
OSC bridges, a timecode-locked `CueList` sequencer, delta-compressed
`DmxRecorder` playback, `previs` fixture-state decoding, lighting-board show
import, and strobe/chase/sine `patterns`. It encodes and decodes the wire
protocols but does no live network output, and GDTF/MVR import is a fail-loud
archive seam.

### @neith/engine-gameplay-tags

GameplayTags hierarchical taxonomy (Rust, `libs/neith/engine-gameplay-tags`,
phase 172.2): dotted `GameplayTag`s with partial hierarchical matching in a
validated `table` with ref-counting and per-tag source tracking, `.ini` +
data-table `sources`, a `TagContainer` with an Any/All/None/Exact + And/Or/Not
`TagQuery` DSL, a block/cancel `RelationshipMap`, a fuzzy-ranked editor
`picker`, rename `RedirectMap` migration, localised `TagMeta`, replication
`TagDelta`s over a `TagDictionary`, and Smart-Object/StateTree/Chooser
`integration` hooks.

### @neith/engine-gas

Gameplay Ability System depth (Rust, `libs/neith/engine-gas`, phase 172.3): an
`AttributeSet` with base/current-value `aggregate` (add/multiply/divide/
override), `GameplayEffect`s with instant/duration/infinite/periodic policies,
stacking and scalable-curve/set-by-caller/custom-execution `Magnitude`s, a
`CueRouter` binding gameplay cues to FX/audio with local/replicated scope,
`Ability` chains gated by cooldown/cost with activation-failure tags, a
`PredictiveAsc` for client prediction with server rollback, level-scaling
`Curve`s, a `GasSnapshot` debugger overlay, and `AscSaveState` persistence
across levels.

### @neith/engine-landscape

Landscape-editor depth (Rust, `libs/neith/engine-landscape`, phase 172.16): a
metres-valued `Heightfield` substrate with `sculpt` brushes
(raise/lower/smooth/flatten/ramp/noise), thermal-talus + hydraulic-droplet
`erosion` simulation, weight-`layers` painting, 16-bit `.r16` heightmap I/O,
Catmull-Rom terrain-carving `splines`, LOD `decimate` with RMS error, streaming
`proxy` tiles, screen-error `nanite` tessellation, dominant-layer physical
materials, mask-gated `grass` scatter, slope/altitude `masks`, and copy/paste
`editops` with hero-hand-edit over a procedural base.

### @neith/engine-livecoding

Hot reload / live coding / editor scripting (Rust,
`libs/neith/engine-livecoding`, phase 172.15): a `FileWatcher` (hash + mtime
diff), a `LiveCoding` session that models the native patch table and call stack
— refusing to patch symbols with live frames (`PatchError::OnStack`), the Unreal
Live Coding safety constraint — plus a `ReloadGraph` cascading
Blueprint/Verse/shader reloads through dependency invalidation, a `ScriptHost`
command registry with `UtilityWidget`s, and a scripted batch `Pipeline`. Honest
scope: it models patch lifecycle and safety, it does not rewrite real machine
code.

### @neith/engine-mrq

Movie Render Queue + Movie Render Graph (Rust, `libs/neith/engine-mrq`, phase
172.4): a serde-scriptable `RenderJob` queue with shots/ranges/versioning, a
`RenderSettings` stack with preset library, temporal + spatial `Accumulator`
sampling with Halton sequences, shutter-angle motion blur and warm-up frames,
OCIO/ACES `ColorPipeline` transforms, MurmurHash3 `cryptomatte_id` + ID/AOV
passes with denoise + `composite_over`, filename-token `NameTemplate` output
versioning, a resume-failed-frame `executor` with farm `distribute`, and a
node-based `RenderGraph` with per-shot branching and variable inputs.

### @neith/engine-pcg-biome

PCG biome core (Rust, `libs/neith/engine-pcg-biome`, phase 172.11):
ecologically-plausible scatter from a declarative description —
`BiomeDefinition`s keyed on climate/elevation/slope/moisture with fuzzy
suitability, a `SpeciesLibrary` with per-species per-biome `DensityCurve`s,
water/path/building `ExclusionMask` geometry, normalised `blend_weights` between
biomes, canopy-dominance `competition` culling, deterministic SplitMix64
streaming-partitioned `ScatterScene` with seasonal/time-of-day hooks, and an
editable `PaintMask`.

### @neith/engine-remote

Remote Control preset + web remote (Rust, `libs/neith/engine-remote`, phase
172.9): a `RemoteControlPreset` exposing properties with typed `PropMeta`
(ranges/steps/groups), a `RemoteEndpoint` dispatching get/set/batch
`Request`/`Response` commands through role-based `Acl` and an `AuditLog`,
bidirectional OSC + 7-bit-scaled MIDI `BindingRouter`, auto-generated web-UI
`Layout` widgets, and preset export/import. The REST/WebSocket transport is
host-provided — this crate models the message layer and is testable without a
socket.

### @neith/engine-switchboard

Switchboard + stage monitor (Rust, `libs/neith/engine-switchboard`, phase
172.8): VP-cluster orchestration — a per-`ClusterNode` lifecycle state machine
(Offline/Launching/Online/Stopping/Error) rejecting illegal transitions,
GPU/CPU/RAM/thermal `Telemetry` with health scoring and `cluster_rollup`, a
per-frustum/per-panel `StageMonitor`, camera-tracking `TrackingStream` health
(jitter/dropout/latency) with a `LogAggregator`, a unified `TakeRecorder`, and a
`Preflight` checklist evaluator. Launch/kill commands drive the state machine;
no real remote processes are spawned.

### @neith/engine-testing

Gauntlet-class automation framework (Rust, `libs/neith/engine-testing`, phase
172.14) — the engine's test _framework_, not a conformance suite: a tiered
`TestHarness` (smoke/integration/e2e) with functional-test `Assertion`s,
golden-`Image` PSNR/MSE compare, `PerfCapture` frame-time percentiles vs budget
baselines, a `DetRng` + `LockedClock` + `Replay` determinism mode, a shrinking
property/fuzz harness with `ChaosCluster` network-partition testing,
content-`validation` rules with gameplay-tag coverage, and a `TriageReport`
aggregator with `FlakinessTracker` and JUnit export.

### @neith/engine-vr-scout

Virtual scouting + Live Link XR (Rust, `libs/neith/engine-vr-scout`, phase
172.10): a `ScoutCamera` with walk/fly/teleport `Locomotion`, snap-turn and
`GridOverlay` snapping, in-VR `Measurement`/`Annotation`/`Markup`, a `ScoutTake`
recorder with storyboard-frame extraction and tolerance-reduced Sequencer
keyframe export, and a `LiveLinkXr` ingest model for Vive/OptiTrack/generic
`TrackerSample`s with timecode, prop tracking, and full-body `BodyPose` joint
streaming.

### @neith/dcc-file-browser

Sovereign File Browser + asset-path management (phase 172.28,
`libs/neith/dcc-file-browser`): `entry` (file entries, filters, previews,
thumbnail regeneration), `paths` (relative/absolute conversion, remap-on-move,
recents/bookmarks), `library` (library path manager + missing-file finder), and
`datablocks` (blend-data browser, drag-drop import, pack/unpack) — the Blender
File Browser / path-management equivalent as a pure headless model.

### @neith/dcc-python-console

Sovereign Python/Script/Info editor workspace (phase 172.27,
`libs/neith/dcc-python-console`): a REPL, script editor with run-script,
operator-history info log, template library, API-symbol autocomplete/browser,
and a statement-level step debugger built around a small sovereign expression
language — deliberately no embedded CPython, so everything is real and testable
in pure Rust.

### @neith/parity172-testing

Cross-crate validation suite for the phase-172 UE/Blender second-parity sweep
(phase 172.29, `libs/neith/parity172-testing`) — integration and determinism
tests spanning the phase's `engine-*`/`dcc-*` crates. Includes an executable MRQ
comparison against the Phase-138 path-tracer transport and a checked-in
texture-paint reference image. The full Phase-27 shoot remains an external
production acceptance gate while its prerequisite filming and virtual-production
artifacts are unfinished.

### @neith/engine-asset-manager

Sovereign Asset Manager & Primary Data Asset system (phase 173.1,
`libs/neith/engine-asset-manager`) — the `UAssetManager`/
`FStreamableManager`/Asset Audit equivalent with deterministic, tick-driven
streaming: `primary_asset` (`Type:Name` ids, soft-object paths), `streamable`
handles with priority-queue ordering, per-type `budget` tracking, `bundles`
chunk composition with platform overrides, a dependency `graph` with
unreferenced/orphan/cycle audit, and the `registry` load/tick/evict runtime plus
an editor `outliner` facade.