Documentation: 0.5.0 (source: v0.5.0).
# The API map

> How the SDK's entry points relate to one another, and the calls that connect them.

Markdown source of https://docs-v0-5-0.atlas-kit-docs.pages.dev/map/ — see https://docs-v0-5-0.atlas-kit-docs.pages.dev/ai/ for the full machine-readable surface.

The SDK mirrors the game's own structure — [the game map](/game-map/) shows
that structure in the game's words. This map shows the same universe from the
SDK's side: once you can see it, most of the API follows from it.

_An interactive version of this diagram is on the web page._

Every box links to that entry's reference. Hovering one isolates what it
connects to, and the labels on the connectors are the actual calls, so the
diagram doubles as API orientation.

The same structure in words, for when a diagram is not what you want:

## The spine

Most reads start from a player and walk down:

```text
Wallet ──▶ Profile ──▶ Character ──▶ Fleet
```

A **wallet** may own a **profile**; a profile has one SAGE **character**; a
character owns many **fleets**. A wallet cannot be turned into a profile by
derivation — profiles are created by the player, so that step needs discovery
or a known address.

## What hangs off a fleet

```text
Fleet ──┬──▶ cargo      (what it is carrying)
        ├──▶ mining     (what it is extracting, and how fast)
        ├──▶ scanning   (what it has surveyed)
        ├──▶ combat     (its combat status)
        └──▶ state      (docked, in transit, mining, …)
```

A fleet's location lives inside its `state`, not as a standalone field, because
where a fleet is depends on what it is doing.

## What hangs off a profile

```text
Profile ──┬──▶ factions   (allegiance, standing)
          ├──▶ loyalty    (epoch contributions, accumulated ATLAS)
          ├──▶ rewards    (treasuries, commitments)
          └──▶ starbases  (this player's state at each starbase)
```

## The world

```text
World ──┬──▶ star systems ──▶ starbases ──┬──▶ markets
        │                                  └──▶ crafting
        └──▶ planets & asteroids ──▶ claim stakes
```

Shared starbase data belongs to the world. A player's own state at a starbase is
separate, which is why starbases appear in both places.

## Underneath everything

```text
client   ── context, cache, provenance, subscriptions
registry ── the Game account's definitions: ships, cargo, recipes, XP
bindings ── the raw generated client (escape hatch)
```

The **client** owns the machinery every read shares. The **registry** holds the
game's static definitions — read once, reused everywhere. The **bindings** entry
is the [escape hatch](/concepts/bindings/) for anything not yet adapted.

:::game[Why one account holds all the definitions]
Ship stats, cargo types, crafting recipes, XP tables — all of it lives in a
single large Game account rather than being spread across many. That is why the
SDK loads and caches it once, in sections, rather than re-reading it per
lookup.
:::

## Reading the map as API

Each arrow is a method, and each cluster is roughly an entry point:

```ts
const character = await sage.characters.forProfile(profileAddress);
const fleets = await character.fleets.all();
const inventory = await fleets[0].inventory.get();
```

Where a name appears in the map, there is usually an entry point of the same
name — `@aephia/atlas-kit/fleets`, `@aephia/atlas-kit/world`, and so on. See
[the reference](/reference/) for the full list.