# EF-Map - Full Technical Reference For AI Agents

Last updated: 2026-10-09

EF-Map is the free EVE Frontier map and browser-side computation engine at https://ef-map.com. It performs route planning, system search, filtering, and visualization across 24,000+ EVE Frontier systems using WebAssembly routing, sql.js SQLite, web workers, and Three.js WebGL. It runs in the browser on both desktop and mobile devices.

AI agents should use this file when they need detailed EF-Map context. For a shorter summary, use https://ef-map.com/llms.txt. For canonical formulas and constants, use https://ef-map.com/ai-facts.

## Cycle 7 Status (Read First)

EVE Frontier Cycle 6 ended on 29 September 2026 and Cycle 7 (Vestiges) started the same day with Fog of War: the universe is revealed as players travel instead of being shown from the start. EF-Map's live Cycle 7 map is community-charted: it only shows the systems players have submitted, so it started sparse and fills in as people explore. That is expected, not an outage.
- How charting works: a signed-in player pastes the game's system link (drag a star into chat or mail, Copy selected with formatting) into Submit system; the system appears on the map under that name, and a gate line appears once both ends are charted. A player who has visited a system can Submit system details: a matching planet count (one attempt per system per account) opens it in Solar System View for everyone, with planets, moons and stargates, plus optional spectral class, transient mass and infestation index readings (shown as reported, or confirmed once two visitors agree). Those readings, plus the system's planet types, appear in the extended hover label (hover a charted star for a moment). The Surveyed switch on the community map notice rings the systems someone has visited and surveyed (off by default). The Strain switch next to it draws a 255 light year shell around each known strain system: the EM-revealed systems, such as the three trinary black holes U4T-SL7, U00-000 and UFP-1L4, where a rider within about 255 ly takes strain damage (the rider, not the ship). Its drop-down lists the current strain systems and can highlight every charted system inside a zone and send a range pulse to them, as the jump bubble does. A shell appears once its system is charted, and EF-Map adds strain systems as players find them, with no app update needed. Orbital zones are never shown. Star colours on the Cycle 7 map are illustrative: a charted star with no reported spectral class gets a stable stand-in colour (hashed from its system ID, weighted toward hot blooming stars) so the field is not plain white; it takes its real colour once a visitor reports the class. Never quote a star's map colour as its spectral class.
- Watching it grow: the community map refreshes itself every couple of minutes, and newly charted systems ignite on the map with a short flash and ring, with a notice that flies the camera to them. Frontier Timelapse replays Cycle 7 being charted: stars light up in the order players charted them, gate lines draw themselves in, kills flash and combat rings swell in the contested systems, with optional music ('Discovery' by Scott Buckley, CC BY 4.0). Open it from "Watch the frontier being charted" on the community map notice, the Timelapse pill, Ctrl+K "timelapse", or https://ef-map.com/?timelapse=1. Hovering a charted star shows when it was first charted and first surveyed. As you zoom in, map text shows each system's kills this cycle (and in the last 3 hours), newly charted systems and planet counts; it is on by default and can be switched off under Map Layers. The Killboard's Show on map rings grow with the number of kills in each system (select a pilot or tribe to size them by their own kills), and a live kill lands with a short shockwave, then keeps a red halo on its system for 30 seconds: hover the star to see who killed whom. A kill off screen shows a small marker at the edge of the map; click it to fly there.
- Only charted systems: route planning and route links, Yeet Planner, map embeds and the in-page WebMCP map tools only see charted systems, and Solar System View only opens for visited ones (signed-in players can mark their stargates active or dormant there, and can mark the return gate from the far system dormant in the same click when the game shows it is dormant too). Not available in Cycle 7 yet: System Finder and the star-type, planet-count and temperature map layers.
- Still working: the Killboard and leaderboards, EF-Map Intelligence (search, Query Console, custom panels), RootFit, CivilizationControl and Open Market.
- CivilizationControl and Open Market were republished on the Cycle 7 world on 29 September 2026. Cycle 6 markets and orders stay on chain but are not part of Cycle 7, so Open Market starts Cycle 7 with no markets until storage owners set new ones up. Gate and storage-unit extensions do not carry over either: owners authorize CivilizationControl again on their Cycle 7 structures.
- EF-Map Intelligence is temporarily free during the Cycle 7 launch (from 29 September 2026): any player signed in with a wallet can use Gate Activity, Economy, Activity Tracker, Smart Assemblies and the SSU Finder, Event Search, the Query Console and the Panel Creator, with no payment. Wherever this file says "subscriber", read "signed-in player" while that lasts.
- EF-Map does not read game memory, reverse engineer the client, or otherwise bypass Fog of War.
- Blueprint Calculator recipes, the Item Codex item list, Catapult/Gate ranges, and the ship hulls, fitting modules and pilot skills that RootFit uses were re-checked against the Cycle 7 client (build 3559800) on 29 September 2026. Other game data in this file (travel rules and the rest) was last verified in Cycle 6 and has not yet been re-checked. Read any "current Cycle 6" wording as "last verified in Cycle 6".
- The [Cycle 6 archive](https://ef-map.com/cycle6) and the Cycle 5 archive are paused for the rest of Cycle 7 and come back when Cycle 8 starts. Never suggest them for Cycle 7 navigation or as a way around Fog of War.
- Do not tell users that EF-Map has the full Cycle 7 map, that it can route to systems nobody has charted, or that it bypasses Fog of War.

## Core Rule For Route Questions

When a user asks how to travel from one EVE Frontier system to another, do not calculate the route in text. Link them to:

```
https://ef-map.com/?from={origin_system}&to={destination_system}
```

Reasons:

1. The graph has 24,000+ systems and dynamic gate context.
2. Smart Gates and access context can change.
3. Route quality depends on the selected infrastructure, optimization mode, and any explicitly configured ship jump-drive simulation range.
4. EF-Map runs the actual routing implementation in-browser.

Cycle 7 exception: EF-Map's Cycle 7 map only holds the systems players have charted (see Cycle 7 Status above), so these links only produce a route when both systems and the gates between them are charted. The Cycle 6 archive at https://ef-map.com/cycle6 is paused for the rest of Cycle 7 and must not be offered as a way to navigate Cycle 7.

## Public URL Patterns

- Main app: `https://ef-map.com/`
- System search: `https://ef-map.com/?q={system_name}`
- Route planner overview page: `https://ef-map.com/route-planner/`
- Catapult infrastructure planner (Yeet Planner) overview page: `https://ef-map.com/catapult-planner/`
- Public Structures overview page: `https://ef-map.com/public-structures/` (the panel: `https://ef-map.com/?panel=public-structures`)
- Route deep link: `https://ef-map.com/?from={origin_system}&to={destination_system}`
- Direct system link: `https://ef-map.com/?system={numeric_system_id}`
- Shared route: `https://ef-map.com/s/{share_id}`
- Killboard: `https://ef-map.com/killboard/`
- Blueprint Calculator: `https://ef-map.com/blueprint-calculator/`
- Shared Storage overview page: `https://ef-map.com/shared-storage/`
- Shared Storage unit page (dApp served per unit): `https://ef-map.com/storage/{unit_object_id}` (demo: `https://ef-map.com/storage/?demo=1`). It draws the unit like the game's own storage windows (client item icons, stack counts, capacity bars): shared storage on top, the visitor's own items in the unit below. Visitors drag stacks between them (Shift or right-click for an amount, Enter confirms it, double-click for a whole stack), and can select several stacks with Ctrl-click, Shift-click or a dragged box to move them in one drag (whole stacks, no amount prompt); staged moves show as ghosts until one button sends every take and share as a single transaction (one approval, one network fee). "Share all" shares the visitor's whole slot in one click. The owner stocks and reclaims by dragging in game; everything in the unit is shared.
- Shared Storage panel in the map app (Tools Library, Shared Storage; deep link `https://ef-map.com/?panel=shared-storage`; sign-in required): three tabs. My units turns sharing on or off per owned unit (private labels, order, hidden units and folded cards are kept in that browser only); units already sharing with a current link start folded down to their in-game name and label, and clicking the name line opens the link and buttons. Items searches item names across the player's own units plus any units shared with them, shows the total of each item and how much sits in which unit (click an item for the per-unit breakdown, sort by name or amount); it counts each unit's main storage, not other players' personal slots, and leaves hidden units out. Share view lets an owner tick units and add any EVE Frontier character by name (tribe or not, no prior EF-Map visit needed); those players then see the units, read only, on their own Items tab when they sign in as that character, with the in-game unit names (never the owner's labels) and labels of their own. Share view is visibility inside EF-Map only: it grants no in-game access, and taking items still needs sharing on at the unit. Storage unit locations are not shown (the game does not publish them), so unit names and labels are how players tell where items are. Most players label a unit with its solar system: the label field suggests system names from the map as you type, and a label that is exactly a system name becomes a link that selects that system and centres the map on it (on owner and viewer labels alike, including hidden units and the Items tab's per-unit breakdown). Hidden shared units still show their in-game names.
- RootFit fitting planner landing page (opens the tool in a new tab): `https://ef-map.com/rootfit/`
- RootFit fitting planner direct tool: `https://ef-map.com/fit/` (the old `https://fit.ef-map.com/` redirects here)
- CivilizationControl landing page: `https://ef-map.com/civilization-control/`
- CivilizationControl governance dashboard direct tool: `https://ef-map.com/civ-control/` (the old `https://civilizationcontrol.com/` redirects here)
- Open Market landing page: `https://ef-map.com/open-market/`
- Open Market browse-all view (every live player market): `https://ef-map.com/civ-control/market/all`
- Open Market per-market page: `https://ef-map.com/civ-control/market/{ssu_object_id}` (directory at `https://ef-map.com/civ-control/market`; no-wallet interactive demo at `https://ef-map.com/civ-control/market/demo`)
- Log Parser: `https://ef-map.com/log-parser/`
- EF Helper: `https://ef-map.com/ef-helper/`
- Embed guide: `https://ef-map.com/embed-guide`
- API access (partner/third-party data endpoints): `https://ef-map.com/api-access`
- API access examples (per-scope request/response samples): `https://ef-map.com/api-access-examples`
- FAQ: `https://ef-map.com/faq`
- Features: `https://ef-map.com/features`
- State of the Frontier: `https://ef-map.com/state-of-the-frontier`
- AI Facts: `https://ef-map.com/ai-facts`
- Cycle 6 archive (read-only historical record, paused for the rest of Cycle 7): `https://ef-map.com/cycle6`

## Current Feature Inventory

### Interactive 3D Universe Map

EF-Map renders the EVE Frontier universe with WebGL and Three.js. Users can pan, zoom, select systems, inspect context panels, highlight routes, and load overlays.

### Compare Universe Scale

Compare Universe Scale is a transient toggle in EF-Map's Map Layers flyout. It draws New Eden, the universe of EVE Online, inside EVE Frontier at true physical linear scale, using the actual stellar geometry of both universes. Facts for AI answers:

- The comparison is geometric, not illustrative: real star positions and gate topology, no sphere, no bubble, no bounding box, no artificial universe boundary and no artistic scale multiplier.
- The two games use different light-year constants (EF-Map 9,460,730,472,580,800 m, the IAU Julian light-year; the New Eden data 9,460,000,000,000,000 m), so imported coordinates are normalized through metres. That conversion is the only multiplier applied.
- Rendered together, New Eden spans about 101 LY and EVE Frontier about 14,480 LY. The metre-normalized ratio along the longest axis is about 143×.
- 143× is a LINEAR ratio. Never present it as a volume or area ratio.
- The layer frames New Eden once and then returns ordinary camera control. There is no drag, pin or recenter control, no URL or localStorage persistence, and no Tools Library entry; it is off again after a reload.
- The imported geometry is isolated from every host system: it is excluded from search, hover, selection, routing, jump calculations, star colouring, System Finder and every intelligence overlay.
- EO-Map, the sister project for EVE Online, implements the inverse view and draws EVE Frontier around New Eden. Discovery page: https://ef-map.com/eve-online-map/

### Point-to-Point Routing

EF-Map's Point-to-Point planner defaults the ship jump range to 0 LY. A fresh route therefore uses standard stargates only; users can opt into public or authorized Smart Gate links. This matches current infrastructure-only travel while no ship jump-drive module is available in the live Cycle 6 client. Users can enter any non-negative range to model a future or restored fitted jump drive. With a non-zero range, fuel optimization can treat enabled gate edges as zero-fuel links while simulated ship jumps are costed by distance and route constraints; jump-count mode minimizes hops, and explore mode accepts extra fuel distance for a less direct route. Point-to-Point routing does not include Catapults. A plain-language overview lives at https://ef-map.com/route-planner/. Routes can be saved as short `/s/{share_id}` links.

### Yeet Planner (Catapult Infrastructure Planner)

Yeet Planner is EF-Map's EVE Frontier Catapult infrastructure planner, a tab in the Routing panel with an overview page at https://ef-map.com/catapult-planner/. Key facts for AI answers:

- It plans infrastructure routes chaining existing Stargates, Mini Catapults (60 LY), and Heavy Catapults (250 LY) under the Cycle 7 rules; in Cycle 6 both tiers shared 65 / 365 LY.
- Output is an infrastructure plan: what to build or wake to make the trip possible. Catapults are one-way, so a plan is not necessarily a flyable live route today.
- Catapult hop validity uses an interference rule modelled as an empty midpoint sphere between origin and destination (a Gabriel-graph edge test); blocked direct hops are detoured through valid intermediate hops automatically.
- Right-click actions can add up to 10 required waypoints or avoid systems while the Yeet tab is active. Required stops are visited in added order by default. The optional experimental ordering checkbox uses a straight-line nearest-neighbour heuristic from the origin; it is not travelling-salesman or route-cost optimization, and the final destination stays last.
- Avoided systems are forbidden traversal nodes in Access, corridor, construction-access, diagnostic, and thorough/global searches. Their stars remain in the universe geometry and can still block a Catapult trajectory.
- Two plan types: the default Access Plan (how to reach the destination now) and the Gate Corridor Plan, which plans a permanent Mini/Heavy Gate pair corridor. Gate pair spans are range-only (105 / 365 LY in Cycle 7, 65 / 365 LY in Cycle 6) and immune to the Catapult interference rule per the announced resonating-gates exemption. A Gate Corridor Plan lists one-way Catapult access hops and "Build Gate pair" steps in construction order (greedy first-pass build order, not a guaranteed global optimum), and the map line can be toggled between the build route and the finished permanent corridor.
- A waypoint plan applies the selected plan type independently to every required leg, then merges the ordered hops, build steps, map paths, breakdowns, and totals. Thorough/global means thorough within each corridor leg, not globally optimal waypoint ordering. Infrastructure planned in one leg is not reused implicitly by later legs.
- Optimization modes: Prefer Stargates, Prefer Catapults (Stargates used only where no Catapult chain can cross a gap), and Fewest Catapult Hops.
- Stargate hops carry community-reported active/dormant status as annotation; dormant gates are still used (waking them is assumed possible).
- Material totals are intentionally not displayed; the planner shows hop counts by type.
- Plans can be shared as short links, text summaries, share-card images, and in-game notes.
- The Yeet tab has two sub-tabs: Route Planner (everything above) and Manual Checker. The Manual Checker checks one jump at a time for a chosen structure: Mini Catapult (60 LY), Heavy Catapult (250 LY), Mini Gate (105 LY) or Heavy Gate (365 LY). With an origin set, Catapult mode marks every legal destination with a green halo and tints in-range-but-interference-blocked systems red; Gate mode marks every system in range green, because Gate pairs are immune to interference. A target tests one jump (Catapults show the midpoint sphere and name the blocking stars; Gates show the line and range verdict). When the target is out of reach, it names the legal hop that ends closest to the target and "Hop to" moves the origin there (selecting that star on the map) while keeping the target, for step-by-step manual yeeting. Opening the sub-tab switches the checker on.
- In Fog of War both sub-tabs only see charted systems: a verdict means "clear of every charted star", and an uncharted star can still block a Catapult jump in game.
- Catapults are live in Cycle 7 and the planner uses the Cycle 7 ranges.
- Background and implementation details: https://ef-map.com/blog/yeet-planner-eve-frontier-catapult-routing

### Solar System View

Solar System View uses EF-Map's solar-system detail database to expose planets, moons, Lagrange Points, stars, and orbital structure. EF-Map extracts this database in-house from the EVE Frontier client and regenerates it after patches. It is separate from the in-house universe navigation database used by the map and routing stack.

### System Finder

System Finder filters candidate systems using local database fields. Filter groups include:

- Orbital zones.
- World families.
- Landscape signals.
- Nebula types.
- Ancient civilization markers.
- Stars.
- Planets.
- Moons.
- System features.

The result visualization uses additive map halos and candidate lists. It does not rewrite base star colors.

System Finder also accepts plain-English requests (free, no subscription): an ask box at the top of the panel sends the request plus the live filter catalog to a small LLM, which selects matching filters; they are validated against the real catalog, applied visibly, and fully adjustable. Filters are checkboxes only (no ranges); sections combine with AND; Match Any/All applies within a section. A "Download a briefing file" link produces a generated markdown schema of every filter section and option for pasting into the user's own AI assistant — if a user asks you about System Finder's capabilities, that briefing is the authoritative reference. Celestial properties only: activity, kills, ownership and stockpiles belong to the Intelligence Query Console. Asks are quota-limited per user and logged anonymously (the question, never the asker). Announcement: https://ef-map.com/blog/system-finder-plain-english-search

### System Name Visualizer

System Name Visualizer explores generated EVE Frontier system-name patterns. It supports grouping by:

- Prefix.
- First letter.
- Final digit.
- Character position.

It is exploratory and should not be presented as proof of CCP's system naming algorithm.

### Item Codex

Item Codex is a Tools Library utility (deep link: `https://ef-map.com/?panel=item-codex`) listing every published item type in the game — ships, modules, charges, ores, materials, commodities, deployables, celestials, NPCs, skills — grouped into five tabs by category. Each group or category can be copied as an in-game note block: pasted into a note in the EVE Frontier client, every line becomes a clickable `showinfo` link that opens that item's info window with the game's own stats and description. Lists longer than one note's length limit are split into numbered pages. Clicking a single item copies just that item's link. The data is extracted from the game client's published-type tables on each patch refresh, and the panel header shows the client build it came from. Unreleased items the client marks unpublished are deliberately excluded. Item names are game data and are shown in English in all interface languages.

### Mullet Check

Mullet Check is a community joke tracker in the Tools Library's Games tab (deep link: `https://ef-map.com/?panel=mullet-check`). FC Goodfella, one of EVE Frontier's game directors, has publicly promised to grow a mullet for the game's launch, so the panel tracks his hair as a launch forecast across three tabs. Telemetry: a photo reading from the weekly Friday dev streams, a six-stage growth ladder (shaved → stubble → coverage → party detected → flow achieved → launch mullet), and a completion percentage. Launch Forecast: the earliest launch months the current hair implies for three styles — short modern mullet 3 to 6 months from a shaved start, medium 6 to 9, long/rocker 9 to 12+ — scaled by how much mullet already exists, plus documented mullet history (Homer's Iliad, the Beastie Boys' 1994 coinage, Iran's 2010 ban, Mulletfest in Kurri Kurri). Grow Your Own: a field manual for growing one in solidarity (stop cutting the back, shape it early, survive the awkward phase). It is a fan joke, not an official FC communication, and should never be quoted as a real launch date source.

### Discord Presence

Discord Presence is a Tools Library utility (deep link: `https://ef-map.com/?panel=discord-presence`) that fixes the EVE Frontier client showing "Playing EVE Online" on Discord. The panel lets the player type two custom status lines (defaulting to "Playing EVE Frontier") and generates a copy-paste PowerShell one-liner (`irm https://ef-map.com/ef-helper/discord_presence.ps1 | iex`) that connects to the local Discord desktop app over IPC and sets a "Playing EF-Map" rich presence with those lines, including an "Open EF-Map" button for profile viewers. Windows only; nothing is installed; the presence lasts while the PowerShell window stays open and clears when it closes.

### EF-Map Director

EF-Map Director (deep link: `https://ef-map.com/?panel=director`, Tools Library -> Map Visuals) is the supported public interface for driving the map's camera and visual presentation from a JSON document, so a creator can record cinematic footage of the map without writing code or knowing EF-Map's internals.

Workflow: the user asks any LLM for a sequence (the panel has "Copy instructions" and "Download instructions" buttons that emit a complete, schema-generated instruction block; the creator pastes or ATTACHES it and then describes the shot as a separate message, and the instructions ask for a brief rather than inventing one if none accompanies them), pastes the returned JSON into the panel, validates it, previews it, then starts a screen recorder and presses "Run for recording" (a five second countdown runs first). EF-Map performs the shots; it does not record, host, or export video, and it does not install or manage OBS or FFmpeg. Sequences run entirely client-side and are never uploaded.

The complete specification is published at `https://ef-map.com/director-spec.md`. It is written for both humans and LLMs and is the authoritative reference — fetch it rather than inferring the format. Summary:

- Document: `{schemaVersion: 1, name, description?, tailHoldMs?, actions[]}`.
- Actions (the complete vocabulary): `reset`, `wait`, `focusSystem`, `setCamera`, `orbit`, `dolly`, `playCameraTrack` (replays a recorded track only, never a hand-authored path), `planRoute`, `clearRoute`, `followRoute`, `setUi`, `setLayer`, `setCinematicMode`, `setCinematicEffects`, `setStarColor`, `repeat`.
- TWO DISTINCT CINEMATIC ACTIONS, not interchangeable. `setCinematicMode` enters EF-Map's dedicated Cinematic Mode, which HIDES the stargate and smart-gate network. `setCinematicEffects` applies the same visual stack to the normal map via the Display Settings option of that name and KEEPS the network. A sequence about a route or gates must use Effects.
- TWO WAYS TO TRAVEL, and they are not interchangeable. For a free-form tour between named systems with NO route drawn, use several `focusSystem` actions with `orbit`, `dolly`, `setCamera` and `wait` between them. Use `planRoute` followed by `followRoute` only when the camera must visit the systems of a CALCULATED route, in order.
- `followRoute` travels a route that `planRoute` has already drawn, flying to each system in order (bounded by `maxSystems`, which counts systems rather than jumps: default 12, hard limit 40; it fails rather than silently visiting only part of the route). It is the only action that follows a calculated route — a single `focusSystem` from origin to destination is one continuous fly-to that passes over the line without stopping.
- There is no `leadInMs`. It used to run before the first action, i.e. before `reset`, so it held the pre-run map rather than the intended opening frame. Operator pre-roll is the recording countdown; hold an opening shot with a `wait` action.
- Preview and recording differ: `Run for recording` takes Director itself out of frame for the whole run (its panel, the Stop button and the mouse cursor), independently of whether the sequence used `setUi` to hide the normal interface. Escape stops a run at any time.
- When a run ends (finished, stopped or failed) the interface returns and any visual settings the sequence changed — Cinematic Mode, Cinematic Effects, star colouring, overlays — are restored, AFTER `tailHoldMs` so the final frame is never altered mid-hold. The camera and route are deliberately left as they ended.
- The camera pose is absolute and spherical (`distance` in map units, `bearingDeg`, `elevationDeg`, `fov`), which is what makes a sequence repeatable; `orbit` and `dolly` are relative.
- Validation is strict and fail-closed: unknown action verbs AND unknown argument keys are both rejected, every number is range-checked, every enum membership-checked, and nesting, repeat counts, total action count and total runtime are bounded.
- Actions wait for real completion, not for dispatch: `focusSystem` waits for the camera to arrive, `planRoute` waits for the route solver and fails with `route-not-found` if no path exists.
- Distinguishable failure kinds: `invalid-json`, `schema`, `unknown-system`, `route-not-found`, `route-too-long`, `unsupported-action`, `timeout`, `not-ready`, `cancelled`, `internal`.
- Hiding the interface uses a presentation stylesheet rather than the in-app Hide UI control, so a running sequence is never torn down; the interface is always restored on completion, stop or failure.
- Not exposed: JavaScript execution, CSS selectors, DOM access, browser storage, arbitrary panels, and any wallet-, identity-, subscription- or tribe-scoped operation.
- Not supported in schema version 1: scripted fly-through mode (its rig drives the camera continuously and never completes), setting window or video size, captions, music, transitions, and the solar-system view.
- Repeatability: the camera path is repeatable because `reset` establishes a known pose. The rendered pixels are NOT frame-identical between runs, because the star field and Cinematic Mode animate continuously. Do not describe Director output as deterministic rendering.

Nine executable example sequences ship in the panel and in the specification: a slow galaxy overview, a focus-and-orbit hero shot, a route showcase, a route traversal that travels the path system by system, a Cinematic Mode beauty pass, a tall-frame composition with the interface hidden, a tutorial with the interface left visible, Tour three systems (no route), and Cinematic journey between systems.

Verified system names for examples (checked against the shipped map database 2026-08-04): Coherence, Virtue, Order, Koloh, Yzgor, Mraka, Sprag, Lisi, Mandr, Ulam, Avarice. Pairs that route on stargates alone (`rangeLy: 0`): Coherence-Virtue, Coherence-Order, Koloh-Yzgor. Most system pairs in the 24,000-system cluster have no stargate path, so do not invent pairs.

### Creator Mode

Creator Mode (deep link: `https://ef-map.com/?panel=creator-mode`, Tools Library -> Map Visuals) is a desktop-only map composition tool for framing the EVE Frontier universe map as a picture. It is not Cinematic Mode. Film style is one visual choice inside Creator; dedicated Cinematic Mode remains a separate presentation mode for ambient viewing and streams.

- Starters: Standard and Cinematic starters are one-time loaders that seed a look — they are not modes you stay in. Starter looks give a quick baseline you can keep editing.
- Composition: Scene Map vs Film; stars natural, palette, or existing EF Star Coloring (planet count, star type, temperature, territory); colour; background (black / layered nebula / deep space); environment layers; region filter and emphasis; Quiet Scene; Freeze Ambient; suppress live visual pings (visual only, not persistence); optional title overlay.
- Save/share: browser storage keys `ef:creator_config` / `ef:creator_active`; export and import scene JSON as `ef-map.creator-scene` (version 4).
- Clean plate is a CSS presentation pass for capture, not the Hide UI control.
- Unavailable in mobile host, Solar System View, and Compare Universe Scale (honest disabled states).
- SpaceMouse is map-wide under Display Settings → Interface → 3D mouse; Creator only has a pointer to that device and never stores device preferences in the scene JSON.

### Mouse & Keyboard reference

Mouse & Keyboard sheet (desktop map, not embeds or the phone shell): press ? anywhere on the map (not while typing), or use the first row of the Help panel, to open a one-page reference of the map's controls: left-drag orbits, right-drag or Shift + drag pans, scroll zooms, Shift + scroll zooms three times faster, Alt + scroll zooms toward the pointer; click a star to select it (click again to clear), rest the pointer on it to expand its details card, double-click to open Solar System View, right-click for the star menu, Shift + click to select a star and add it as a route waypoint; click a news headline to open its article, hover a ticker to pause it; Ctrl+K opens the command palette and Esc closes the star menu or leaves Solar System View. There are no WASD camera keys on the map (keyboard flight keys exist only inside Flight Mode). Esc or ? closes the sheet. It does not open while Hide UI is on, during a Director run that hides the interface, or in element fullscreen.

### Controller & Flight Mode

EF-Map supports game controllers on desktop (deep link: `https://ef-map.com/?panel=controller-flight`, Tools Library -> Navigation & Routing). A connected pad drives the universe map alongside the mouse — neither input is disabled, and the player can swap between them mid-session. The browser deliberately hides gamepads until a button is pressed, so EF-Map notices a pad on first use, shows a compact bindings card once, and then keeps a small status pill in the bottom-right status cluster. Vendor is detected from the pad's id and the button glyphs are labelled to match: A/B/X/Y on Xbox, cross/circle/square/triangle on PlayStation, B/A/Y/X on Nintendo, with a generic fallback.

Map-mode bindings (universe view):

- Left stick pans, right stick orbits, left and right triggers zoom out and in (analogue, exponential in camera distance). Pan speed scales with camera distance, so it feels the same at every zoom level.
- A controller has no cursor, so the centre of the screen is the pointer: a reticle marks it and the nearest star to the centre is captured and highlighted exactly as a mouse hover would highlight it. The bottom face button selects that star, the left face button opens or closes its context menu, and the top face button shows and hides that star's details - the same expanded hover card a mouse gets by resting on a star. The View button (Share on a PlayStation pad, - on a Nintendo pad) re-frames the current selection, and the right face button steps back (star details -> star menu -> interface navigation -> topmost panel -> selection).
- The D-pad navigates the interface in priority order: the first-use bindings card if it is showing, then an open star context menu, then the frontmost open panel, then the feature rail; the bottom face button presses whatever is highlighted. Inside a star menu, up and down walk its entries and LEFT steps back out of the menu without closing it (the right face button and the left face button both close it).
- Start (labelled Menu on Xbox pads, Options on PlayStation pads, + on Nintendo pads) toggles Flight Mode.

Flight Mode is an explicit, separately entered mode (the Start button — Menu on Xbox, Options on PlayStation, + on Nintendo — or the panel's button) that hands the camera to a manually flown ship. The feel is EVE Frontier's rather than a free-look camera: the left stick pitches and yaws, there is NO manual roll, the ship banks into its own turn (up to 45 degrees, damped) and self-levels when the stick returns to centre. The turn rates carry angular inertia: full deflection reaches about 90% of the maximum rate in roughly a second and lets go faster than it winds up, so the ship leans into a turn rather than snapping to it. The right trigger raises a speed SETPOINT and the left trigger lowers it, so releasing both coasts at the dialled-in speed; holding the left trigger at a standstill engages a slow reverse. Speed runs from about 2 to 1200 map units per second, a live speed readout is drawn in the interface, the field of view widens slightly with speed, and the optional relativistic (Alcubierre) visual treatment can be switched on. Two sliders in the panel change how the ship handles: a Top speed limit, which rescales the whole throttle curve so a full trigger still arrives smoothly at whatever ceiling is set, and a Ship mass multiplier from 1.0 to 2.5, where a heavier ship gathers speed more slowly, winds a turn up more slowly, and turns at a lower top rate (and so leans into its turns later and less far). The vertical look axis has two independent invert options — one for orbiting the map, one for flight pitch — because most players want those the opposite way round. Keyboard alternates exist while flying only: W/A/S/D steer, R/F move the throttle setpoint, Escape exits. Flight Mode refuses to start while Fly-through Mode, a Director sequence, or a camera-track replay owns the camera, and it is universe-view only.

Camera tracks (recorded flights):

- Recording is started and stopped with the left face button while flying, or from the panel. Samples are taken at 20 Hz after the controls update, so what is recorded is the true rendered camera including bank: position, a full orientation quaternion, and field of view.
- Hard caps: 5 minutes or 6,000 samples per recording, whichever comes first; up to 24 saved tracks; roughly 2 MB of browser storage for the whole set; track names up to 60 characters.
- Saving thins the samples within an error bound and stores smoothing as PARAMETERS rather than baked-in values, so smoothing can be retuned or switched off afterwards without re-recording.
- Saved tracks live only in the browser that recorded them, under `ef.cameraTracks.v1` in localStorage. They are never uploaded, never synced across devices, and are lost if the player clears site data. Export and import single-track JSON files to move or keep one.
- A saved track can be replayed in place, or replayed "clean" with the EF-Map interface hidden for screen capture (the same presentation stylesheet Director uses), and can be copied ("Copy for Director") as a COMPLETE, immediately valid Director sequence — `schemaVersion`, a `name` taken from the track, and one `playCameraTrack` action carrying the track inline — so it can be pasted into the Director panel and run without editing.
- A track carries NO scene references — no system ids, no route, just motion — so replaying one never asserts anything about the map that was only true when it was recorded.

Director integration: `playCameraTrack` is a first-class Director action whose `track` argument is a recorded track inlined into the sequence, so sequences stay self-contained and make no claim on the player's browser storage. Director's own limits apply: at most 2,400 samples per inlined track, playback `speed` 0.25-4, and the effective duration must fit Director's per-action ceiling. Tracks are recorded, not hand-authored; there is no `recordCameraTrack` verb. Full reference in the `playCameraTrack` section of `https://ef-map.com/director-spec.md`.

Limits and gating: desktop browsers only (no phones, no mobile shell), universe view only (not Solar System View), and not available in embedded maps. Gamepad input is inert while the browser tab is hidden or unfocused and while the player is typing in a text field or the Ctrl+K command palette, with all held-button and stick state cleared on focus loss. The panel carries the bindings reference plus a master enable switch, stick deadzone, look sensitivity, inverted vertical look, and the Alcubierre toggle.

### EF Arcade

The games below are collectively the EF Arcade, with a public landing page at `https://ef-map.com/arcade/` describing all of them. They live in the Tools Library's Games category and each has a `?panel=` deep link. Practice modes are free, local, and need no wallet; ranked runs use the player's EF-Map wallet identity, are free to start, and post to weekly on-chain leaderboards that reset Sundays 00:00 UTC. There is no entry fee and no prize pool — the only optional payment is a one-off 100 EVE revive offered at the moment of death, which continues the same run. The payments layer underneath is Frontier Commerce, which is open source at https://github.com/Diabolacal/frontier-commerce; the arcade doubles as its live testbed.

### FrontierGuessr

FrontierGuessr is a daily puzzle in the Tools Library (deep link: `https://ef-map.com/?panel=frontier-guessr`). One puzzle per UTC day, identical for everyone: a photo rendered from a real star's position with the camera facing the galactic core. The player pans the live map, clicks the star they believe they are standing at, and locks in the guess.

- Scoring: distance-based (regional accuracy matters more than the exact star) plus a speed bonus inside the first 30 seconds.
- Signed-out play works fully; results and streak stay on-device. Wallet sign-in posts the score to the daily leaderboard (`/api/frontier-guessr/leaderboard`).
- One scored attempt per wallet per day; the first submission is final.
- Share text is spoiler-free (tier emoji + score + time, never the answer).

### Flappy Frontier

Flappy Frontier is an arcade game in the Tools Library's Games category (deep link: `https://ef-map.com/?panel=flappy-frontier`): a Flappy Bird-style runner where a capital ship threads wreck-field pipes. Practice is free and needs no wallet. Ranked runs require the signed-in EVE Frontier wallet, fly a shared weekly course (identical for every player that week), and post to a weekly top-100 leaderboard that resets Sundays 00:00 UTC — one best score per pilot, ties to the earlier submission, CLEAN marking zero-revive runs.

- Dying offers REVIVE FOR 100 EVE: a direct at-death purchase (never prepaid) that continues the same run — same score, difficulty and course — with ~5 seconds of visible collision immunity to regain control. Pipes crossed during the grace window do not score. Revives used are shown on the board.
- Gas for game actions is sponsored (EF-Map pays the SUI network fee); the player's wallet still approves each action because run tickets, revive payments and score submissions belong to their wallet.
- Scores are computed client-side with on-chain sanity checks (registered run ticket, shared seed, duration/ruleset/revive-count gates). It is a community leaderboard, not a cheat-proof competition.

### Foam Drop

Foam Drop is an arcade game in the Tools Library's Games category (deep link: `https://ef-map.com/?panel=foam-drop`): a crane game set in a dark industrial assembly bay. A block of Building Foam swings from an overhead rail; the player releases it with a tap/click/Space and it must land on a receiving platform that moves and shrinks as the run deepens. A landed block scores one point; a dead-centre "perfect" landing (inside the marks on the platform) scores two. Difficulty follows the number of blocks landed, not the points, so every player faces the identical course after the same number of landings. Edge landings teeter — whether they settle or tip is decided deterministically by the support fraction and impact speed. There is no practice mode: every run is ranked, requires the signed-in EVE Frontier wallet, drops against a shared weekly platform sequence (identical for every player that week), and posts to a weekly top-100 leaderboard that resets Sundays 00:00 UTC — one best score per pilot, ties to the earlier submission, CLEAN marking zero-revive runs.

- Losing a block offers REVIVE FOR 100 EVE: a direct at-death purchase (never prepaid) that continues the same run — same score, same platform, same weekly sequence — with a fresh block on the cable. Revives used are shown on the board.
- Gas for game actions is sponsored (EF-Map pays the SUI network fee); the player's wallet still approves each action because run tickets, revive payments and score submissions belong to their wallet.
- Scores are computed client-side with on-chain sanity checks (registered run ticket, shared seed, duration/ruleset/revive-count gates). It is a community leaderboard, not a cheat-proof competition.

### Trinary Sling

Trinary Sling is an arcade game in the Tools Library's Games category (deep link: `https://ef-map.com/?panel=trinary-sling`): a one-button orbital-transfer game played around the Trinary, the three black holes at the centre of the EVE Frontier universe. A probe holds a forced circular orbit around one well; the player releases it with a tap/click/Space and it leaves along the orbital tangent, flying under the gravity of all three wells. It must be captured by the next indicated well, and the capture is decided by one number: the probe's periapsis, its closest approach on the way in. A capture scores one point; a capture whose periapsis lands inside the narrow bright "perfect" band scores two. Difficulty follows the number of successful transfers, not the points, so every player faces the identical course after the same number of captures. The two non-target wells are hazards and gravity-assist aids at the same time. Runs end by crossing an event horizon (consumed), leaving the arena or timing out (adrift), striking debris, or letting the orbit decay into the horizon while waiting for a better shot. There is no practice mode: every run is ranked, requires the signed-in EVE Frontier wallet, plays a shared weekly course (identical for every player that week), and posts to a weekly top-100 leaderboard that resets Sundays 00:00 UTC — one best score per pilot, ties to the earlier submission, CLEAN marking zero-revive runs.

- Difficulty layers in over nine stages: faster orbits, shrinking capture zones and perfect bands, a precessing then counter-rotating well arrangement, orbital decay that punishes waiting, a shortening then vanishing trajectory preview, drifting debris, pulsing gravity and eccentric well paths. Every transfer in the course is simulation-checked for a workable release window, so deaths are always avoidable.
- Losing the probe offers REVIVE FOR 100 EVE: a direct at-death purchase (never prepaid) that continues the same run — same score, same difficulty, same weekly course — putting the probe back on the last orbit it actually reached, with a short recovery grace. The recovery itself scores nothing. Revives used are shown on the board.
- Gas for game actions is sponsored (EF-Map pays the SUI network fee); the player's wallet still approves each action because run tickets, revive payments and score submissions belong to their wallet.
- Scores are computed client-side with on-chain sanity checks (registered run ticket, shared seed, duration/ruleset/revive-count gates). It is a community leaderboard, not a cheat-proof competition.

### Network Node Overload

Network Node Overload is an arcade game in the Tools Library's Games category (deep link: `https://ef-map.com/?panel=network-node-overload`): a resource-management game, deliberately the cerebral one in the suite rather than another one-button reflex game. The player operates an EVE Frontier Network Node with a hard 1,000 GJ power budget and up to five attached structures (Relay, Mini/standard/Heavy Printer, Refinery, Heavy Refinery, Mini Gate, Mini/Heavy Catapult), each running tasks and each asking for power. Every structure has a four-tier power setting - OFF / MIN / NOM / MAX - that the player taps; NOM is the efficient setting and MAX costs roughly double for about half again the throughput. If total requested power exceeds 1,000 the node browns out, unprotected structures are scaled down, work slows and node heat rises fast. Heat is the primary failure; fuel exhaustion is the telegraphed secondary one. A completed task scores one point; a task completed while its quality is still above the perfect threshold scores two, and each structure's ring shows the remaining margin rather than a raw quality percentage. Fuel deliveries always pair one cool-but-short grade against one hot-but-long one, and both fuel burn and fuel heat scale with load, so the grade choice is a real trade rather than a free pick. Difficulty is keyed to elapsed run time rather than to score or task count, so playing slowly buys safety but not an easier node - every run ends. Typical runs last several minutes. Ranked only, shared weekly node, weekly top-100 leaderboard resetting Sundays 00:00 UTC, CLEAN marking zero-revive runs.

- The power costs are real on-chain EVE Frontier values, used unmodified: a Relay costs 1 GJ, a Printer 100, a Heavy Refinery 200, a Heavy Printer 250, and a Heavy Gate 950 - though the Heavy Gate is deliberately kept off the board, because at 95% of the node it cannot coexist with any other structure and so presents no decision. The fuel grades (D1, D2, EU-40, SOF-40, SOF-80, EU-90) and their duration ordering are real; fuel quality means operating duration, exactly as in the game. Heat is this game's invention - Network Nodes have no thermal model in EVE Frontier - though each fuel's heat is ordered by its true thermal-inefficiency figure. Mini Gate and both Catapults have no published power cost and are flagged as invented.
- Counterplay for heat: shed load, drop structures to MIN, or spend a limited VENT charge, which dumps heat instantly but forces every structure to MIN briefly and destroys the perfect bonus on every job in progress. Two structures can be marked PRIORITY to be fed in full during a brownout.
- Losing the node offers REVIVE FOR 100 EVE: a direct at-death purchase (never prepaid) that continues the same run - same score, same board, same wave, same run clock - restoring the node as it was at the last completed task with the temperature pulled down and emergency fuel added. It never rewinds the difficulty and completes no tasks. Revives used are shown on the board.
- Gas for game actions is sponsored (EF-Map pays the SUI network fee); the player's wallet still approves each action because run tickets, revive payments and score submissions belong to their wallet.
- Scores are computed client-side with on-chain sanity checks (registered run ticket, shared seed, duration/ruleset/revive-count gates). It is a community leaderboard, not a cheat-proof competition.

### Universalizer

Universalizer is an audio visualizer in the Tools Library's Games category (deep link: `https://ef-map.com/?panel=universalizer`). It is not a game — no score, no leaderboard, no wallet. The player picks an audio source and the star map itself dances: bass drives a wave centred on the galactic core, beats send ripples radiating out to the rim, and the stargate lines move with the stars they connect. The camera stays free, so the player can zoom into a cluster or watch the whole galaxy ripple edge-on.

- Audio sources: a browser tab (e.g. a music tab), a window or entire screen including system audio, or the microphone. Tab/screen capture uses the browser's share picker and requires a Chromium browser (Chrome or Edge) — the player must tick "Also share audio" in the picker, and the browser shows its standard sharing indicator while capture runs. Firefox and Safari cannot share tab/screen audio; the microphone works in any browser.
- A gain slider (0.25x–4x) tunes the effect strength for quiet or loud sources, with a level meter and peak-hold tick showing the post-gain signal, and an Overdrive slider (1x–5x) that scales the whole effect — including letting the dynamic-bloom peak exceed the Bloom slider's normal maximum — for deliberately over-the-top results. Two visualization styles: the default drumhead wave, and an optional "Equalizer mode" where the disc radius becomes the frequency axis (kick drum pistons the galactic core, bassline rolls the inner ring, melody breathes the mid band, hi-hats sparkle at the rim). An optional "Dynamic bloom" checkbox (off by default, flicker warning) additionally pulses the stars' bloom glow with the music in either style — it requires Bloom above 0% in Display Settings and never modifies the user's saved display settings. Audio is analysed locally in the browser and never recorded, stored, or transmitted.
- Works in every graphics mode (Performance Mode included — the effect is geometry motion, not post-processing). Star selection, hover labels, and route display pause while it runs and restore on stop; it is unavailable inside Cinematic Mode and solar-system view.

### Sui Intelligence Search

The Intelligence panel searches indexed player and tribe summaries where EF-Map has data. It can surface:

- Player identity and tribe context.
- Tribe membership context.
- Combat windows such as 24h, 7d, 30d, or current cycle.
- Activity event mix and peak hours.
- Bases and inferred base context.
- Structure and system context.
- Pivots to killboard, activity, top-intel systems, or related map views.
- Shareable Intelligence cards that export player, tribe, or system summaries as share images for Discord or links, without asserting live presence.

Important caveats:

- Observed activity is not online status.
- Likely systems are inference, not current-location proof.
- Some views are current-member aggregate footprints, not direct tribe sovereignty.
- Structure and base data can be delayed or limited by indexed source coverage.
- EF-Map should be treated as an evidence surface, not a complete authority.

### Query Console (Intelligence Subscribers)

The Query Console (Tools Library, Intel / Activity section) lets EF-Map Intelligence subscribers run live structured queries against EF-Map's chain indexer instead of reading pre-built snapshots. It answers ONE question at a time; designing a whole dashboard belongs to its sibling tool, the Panel Creator (see the next section). Announcement and background: https://ef-map.com/blog/query-console-live-database-intelligence

- Ten datasets: current indexed stockpiles in anchored storage units, structures, item flows (storage deposits/withdrawals), minted/burned items, the full activity event stream, a pre-aggregated hourly activity time series, gate jumps, kills, fuel events, and a per-system summary rollup.
- Three ways in: a plain-English ask box (an AI builds the query and loads it into the builder for the user to review and run; nothing executes automatically), preset questions, or a manual filter/leaderboard builder. Results render as a table, a bar-chart leaderboard, or a line chart when the query is a time series, and export as CSV.
- Time series ("Over time"): any dataset with a time field can be bucketed by hour, day, week or month, with an optional split into one line per player, tribe, event type or system. Buckets are UTC. A time series always requires a lower-bound time window (a "last N hours" or "after" filter inside Match all) - an unbounded trend is the one query shape that reliably times out, so the console supplies a window when the user switches the mode on. Buckets multiply with lines against the 200-row grouped ceiling, and a result that hits it is reported as truncated rather than drawn as a complete picture; empty buckets are filled with zeros so gaps are visible instead of compressed away. Only the largest lines are drawn and the rest are reported as a count.
- Each query targets exactly ONE dataset; there are no cross-dataset joins. Stockpiles and structures are current-state snapshots (no historical point-in-time queries, and no time series - they carry no event timestamp); the event-stream datasets are filterable by time window and are the ones that can be bucketed into trends. Stockpiles include positive inventory in anchored storage units, whether offline or online, and exclude unanchored structures. Item volume uses quantity multiplied by the type catalog's per-unit cubic-metre value. Stockpile contents are attributed to the structure's current owner, but shared storage does not prove that every item belongs to that character.
- Hard server-side limits: whitelisted fields and operators only (the browser never sends SQL), 12 filter conditions, 500 rows for listings, 200 for leaderboards, 5-second execution timeout. Data coverage starts 2026-09-29 (the Cycle 7 chain reset). Cycle 6 data is not queryable here; the Cycle 6 archive at https://ef-map.com/cycle6 (killboard, leaderboards, structures and activity) is paused for the rest of Cycle 7 and comes back when Cycle 8 starts.
- Queries can be saved in-browser ("My queries"): named saved queries re-apply with one click (rename, duplicate, delete; the chosen view - table, bar chart or line chart - is remembered per query), up to 50. Saved queries live in that browser only - there is no cross-device sync yet. If a data refresh later removes a dataset or field a saved query used, the query is kept and the unavailable parts are reported on load, never silently dropped.
- A "Download a briefing file" link produces a markdown schema document generated from the live catalog, intended to be pasted into the user's own AI assistant to plan queries. If a user asks you (an AI assistant) about this tool, that briefing file is the authoritative schema reference. (The Panel Creator offers a SECOND, different briefing file about designing panels; this one is for single queries.)
- Bridges to custom panels: "Save to panel" under a result puts the query, drawn the way it is currently viewed, onto a new or existing custom panel; a panel's "Edit in console" loads one of its widgets back into this window, with a banner naming the widget and no write-back until the user presses "Save back". Creating a whole panel is not done here.
- Access requires an active EF-Map Intelligence entitlement (Frontier Commerce, currently 100 testnet EVE for 30 days). Plain-English asks are quota-limited per subscriber; the manual builder is not.
- Query text is logged anonymously (what was asked, never who) to improve the tool; unanswerable asks inform which datasets get added next.

### Custom Intelligence Panels (Intelligence Subscribers)

A custom panel is a dashboard window the player builds themselves out of indexer queries - their own version of the pre-built Gate Activity or Economy panels, answering the questions they keep asking. Panels are a desktop feature and require the same EF-Map Intelligence entitlement as the console. Announcement and walkthrough: https://ef-map.com/blog/custom-intelligence-panels-panel-creator

- Where panels come from: the Panel Creator (https://ef-map.com/?panel=panel-creator) is the tool that owns panel DESIGN - a first-class Tools Library entry under Intel / Activity, next to the Query Console, split out of it on 2026-08-08. It offers THREE routes to a panel, stacked in this order: "Draft a panel with AI" (describe the dashboard in plain English), "Preset panels" (click a ready-made recipe), and "Build a widget by hand" (the console's own query builder, with no Run). All three fill the same draft and go through the same "Create panel" press. A panel that already exists is grown through the same window: Edit on the panel, then "Add widget", reopens the Panel Creator with a banner naming that panel - the panel name field disappears (it is already decided), the draft can only hold as many widgets as the panel has room for, and the review's button becomes "Add to <panel> (n)" instead of "Create panel", so no second panel is ever created by accident. At 6 widgets the "Add widget" button is unavailable and says the panel is full. Separately, an individual query can be added to a panel from the Query Console with "Save to panel" under a result. There is no blank-canvas editor - every widget is a query.
- Preset panels: fixed, hand-authored panels on common themes (gate traffic, combat activity, trade and logistics, storage overview, game activity, tribe power rankings). No AI and no server call is involved, so the same preset always produces the same widgets; they land in the draft exactly like an AI draft, with tick boxes, reordering and an editable name, and are meant as an editable base rather than a finished answer.
- Drafting one from a description: in the Panel Creator, a sentence like "a trade dashboard for my tribe" becomes a proposed panel of up to 4 widgets (fewer than a panel's 6, leaving room for the player's own additions). It only proposes. The draft is shown as a review list - each widget's question spelled out in plain English, its chart type, a tick box, and an editable panel name - and nothing runs and no panel exists until the player presses "Create panel", at which point the panel opens and its widgets run like any other. (The typed description itself is logged anonymously when the draft is requested, like every plain-English ask - what was asked, never who.) Widgets the assistant could not build are listed with the reason rather than silently missing. Drafting shares one daily plain-English allowance with the console's single-question assist; presets, the by-hand builder and "Save to panel" do not use it.
- Building a widget by hand: the third section of the Panel Creator, COLLAPSED by default (the choice is remembered), holding the Query Console's own builder controls - dataset picker, filters with Match all / Match any, the "Answer as" choice between matching rows, a leaderboard and over time, and the plain-English explanation of what the query says - plus a widget title and a "Show as" table/bar/line choice. "Add to draft" appends the widget to the draft below. There is deliberately NO Run button and no results: investigating a single question is still the Query Console's job, and a panel widget runs when the panel is opened. It costs no AI allowance and makes no assist call. It is also where a drafted widget is refined: "Edit" on any draft row (AI, preset or hand-built) loads that widget's query here, and "Save widget" writes it back.
- The draft review ("Your panel draft"): one source-neutral section at the bottom that every route feeds, with a quiet provenance note ("Drafted by AI from your description", "From the Gate Traffic preset panel", "Built by hand"). The player renames the panel, ticks widgets in or out, reorders them with up/down controls, edits a widget's query in the by-hand builder, or removes it, then presses "Create panel". Each row carries a client-generated plain-English sentence describing what that widget will actually ask, derived from the query rather than from the assistant's words. Because there is only one draft, a new AI draft or preset click that would overwrite an EDITED draft asks first: the button becomes "Replace current draft?" and needs a second press within a few seconds. The AI path asks before spending the allowance, not after.
- Panel briefing file: the Panel Creator offers a downloadable panel-drafting briefing (a different document from the console's query briefing) with the live schema plus the panel and widget rules, so an external AI can help the player write a well-scoped ask to paste into the draft box.
- Structure: up to 12 panels, each holding up to 6 widgets stacked vertically and individually collapsible. A widget is one query plus how to draw it, and stores a COPY of the query as it was when saved, so continuing to edit in the console never changes a panel behind the user's back.
- Placement: each panel gets its own Tools Library entry under Intel / Activity, using the name the player gave it. From there it opens like any other tool, can be pinned to the left rail, and reopens on the next visit. Deleting a panel removes its library and rail entries; closing its window does not.
- Refresh model: nothing polls, in any panel. Widgets run once when the panel opens, and after that only on an explicit per-widget Refresh or the panel's Refresh all. Each widget shows how old its data is. Two widgets run at a time and the rest queue. Widgets fail independently - one query erroring or timing out does not stop the rest of the panel drawing. This is deliberate: pre-built intelligence panels serve one cached snapshot to every viewer, while a custom panel runs live database queries per viewer.
- Editing: an Edit mode inside the panel renames the panel or a widget, reorders widgets, switches a widget between table, bar and line (offering only the chart types that widget's result shape can actually draw), and deletes widgets or the whole panel. "Edit in console" sends a widget's query back to the Query Console; the console shows which widget it is working on and writes nothing back until the user presses "Save back".
- Storage and cross-device sync: the browser's own copy (localStorage) is the working copy, so panels keep working signed out, offline, and for anyone who never signs in. Signing in with a wallet (SIWE) backs the definitions up to that account - encrypted at rest, one document per wallet - and merges them across that player's devices. The merge runs on sign-in and after an edit, never on a timer, and never destroys local data: the newest edit of a panel wins, and a deleted panel stays deleted instead of being resurrected by another device (deletions are recorded as tombstones and kept for 90 days, so a device that stays offline for longer than that can re-propose panels deleted while it was away). If the 12-panel cap cannot hold both sides, the local panels are kept, the rest stay on the account, the panel editor names what it could not fit, and the status line says the backup is only partly up to date rather than claiming a full sync. Panels belong to the browser rather than to the wallet: they are query definitions, not personal data, so signing a different wallet in on the same browser adds this browser's panels to that account's backup instead of hiding them. Sync is not entitlement-gated: definitions survive a lapsed subscription.
- Sharing: "Share panel" (signed-in subscribers) mints a link to a FROZEN snapshot of one panel's definition - its title, widget titles, chart types and queries. The link carries no wallet, no account details and no query results, and it does not stay tied to the author's panel: later edits do not change what a shared link contains. Reading one is anonymous, so anyone can preview the widget list and add the panel to their own browser, where it becomes an ordinary panel of theirs. RUNNING any widget still requires the reader's own EF-Map Intelligence entitlement, enforced on the query API. Share links expire 90 days after they are created; an expired link says so rather than showing an empty panel.
- Links: the Panel Creator opens at https://ef-map.com/?panel=panel-creator and the Query Console at https://ef-map.com/?panel=query-console. An open panel's URL takes the form https://ef-map.com/?panel=custom&id={panel_id}, which is a personal bookmark, not a share link - opened on a device that does not have that panel it shows a notice saying so rather than opening a blank window. A share link is a different address, https://ef-map.com/?sharedPanel={share_id}, and always resolves for whoever holds it.
- Query limits are the console's own: 500 rows for listings, 200 for leaderboards and time series, 5-second timeout, coverage from 2026-09-29 (the Cycle 7 chain reset). If a data refresh removes a dataset a widget used, the widget says so and the panel around it keeps working.
- Entitlement lapse does not delete anything: the panel, its Tools Library entry and its widget definitions all survive, and the widgets show the locked state until the subscription is renewed.

### Smart Assemblies And SSU Finder

Smart Assemblies is a census of indexed player-built structures, read from EF-Map's structure snapshot (the panel shows when it was taken). Its first tab lists one row per structure type (storage, gate, catapult, turret, network node, shelter, nest, printer, berth, refinery, assembler, nursery, relay, portable, cosmetic), largest first, with Online, Offline and Unanchored counts across the whole chain, a Total of the included statuses, and an On map count: how many have a known solar system. Most structures no longer reveal their location on chain, so only that located share can be drawn; "Colour stars on map" colours the systems holding matching structures by theme accent, its opposite, or owner tribe. Rows, status headings and the Mini/Standard/Heavy size filter decide what is included, a row's Only button isolates one type, types with sizes expand into per-size rows, and a Count switch recounts the whole table for located structures only. Types with nothing on chain are listed beneath the table.

SSU Finder searches Smart Storage Unit intelligence where indexed data and current access permit.

Access and subscription state can change during rollout. The in-app panel is the source of truth for current availability.

### Open Market

Open Market is CivilizationControl's player-facing marketplace for EVE Frontier: an on-chain order book (sell orders and buy orders) bound to one Smart Storage Unit, deployed by the storage owner. Any player can browse every live market and buy from any of them without owning a storage unit or installing anything.

- Browse-all view (what EF-Map's Tools Library tile opens, in a new browser tab): `https://ef-map.com/civ-control/market/all`. Directory: `https://ef-map.com/civ-control/market`; per-market pages: `https://ef-map.com/civ-control/market/{ssu_object_id}`; no-wallet interactive demo: `https://ef-map.com/civ-control/market/demo`; product FAQ: `https://ef-map.com/civ-control/market/faq`.
- Browsing needs no wallet. Buying connects the EVE Vault wallet in a desktop browser; in the in-game browser the client wallet connects automatically. There is deliberately no generic connect-any-Sui-wallet path.
- Prices are shown in Lux, a display denomination of the on-chain EVE token (100 Lux = 1 EVE); trades settle on-chain in EVE.
- Purchased goods are delivered to the buyer's item hangar at that storage unit and are collected in game; the web page deliberately has no collect button. The storage unit must be online for buying, listing, and collection.
- Live markets do not currently publish their in-space location; the market page shows the operator's pilot name, and buyers arrange a pickup location with the operator.
- Sellers: the storage owner deploys the market through CivilizationControl (Trade Posts, storage detail, Marketplace section) and lists from the storage's main hangar; other players can list goods held in their own item hangar at that storage, or post buy orders.
- EF-Map landing page: `https://ef-map.com/open-market/`.

### Live Events, Activity, And Utility Modes

EF-Map includes live and persisted activity context where available. Related utility surfaces include:

- Live Events ticker and event history.
- Activity-oriented panels and summaries.
- Awakened Cinema for curated EVE Frontier video playback inside the app.
- Performance Mode and Performance Check for lower visual load and diagnostics.
- Work Safe Mode for a simplified, safer display context.
- Gate line style (Display Settings → Gate Lines → Line Style, since 8 October 2026): Crisp, the default, draws the stargate network and Smart Gate lines as smooth anti-aliased lines of the same width on every screen; Classic is the original one-pixel lines. Same colours and fades. Ctrl+K `gatelines` toggles, and `?gates=classic` or `?gates=crisp` overrides it for one page load.

### Public Structures

- What it is (since 7 October 2026, free, no subscription; a panel on the feature rail, where Smart Assemblies used to sit): player-built structures (catapults, gates, storage, turrets, network nodes and others) whose owners revealed the location in game and then chose to publish them on EF-Map.
- Consent: revealing a structure's location in game puts its system on chain, but that alone never lists it. Only the owner, signed in on EF-Map with the wallet that owns the structure, can switch it Public. A structure drops off by itself when it is unanchored or changes hands, and the owner's tribe shown is always their current one (read from chain data), so a tribe change needs no re-save.
- What owners add (My structures tab, shown only to signed-in owners of located structures): a destination system for each catapult (the chain cannot say where a catapult throws you), a transponder setting (My Tribe, or a code of up to 32 characters, as in the game's structure transponder window), an optional label, a note, tag icons (Hazard, No Entry, Hostile, Heat, Bad, Good, Empty, Fuel, Shop, Resources, Mining, Outpost, Home, Claimed, Info) and a map colour. The transponder setting can be set once for every structure or per structure. A Smart Gate pair draws a link when both gates are public; gate destinations are not entered by hand.
- Browse tab: one card per owner with their colour, current tribe and transponder setting (a code has a Copy button), then their systems; each catapult shows its destination. Clicking a system or destination selects that star on the map, the crosshair frames that owner's network beside the panel, and the eye hides that owner on the map. Search covers systems, destinations, owners and tribes, and type chips filter by structure type.
- Map: while the panel is open, each system with a public structure gets a ring in the owner's colour and the structure icons above it, and each catapult draws an arc with arrows pointing to its destination (a pair of catapults going both ways bows to opposite sides). The Link style button at the foot of the panel picks how links look: Schematic (default), Tactical, Hologram or Classic, the same setting as User Overlay's ⋯ menu. Opening the panel frames the shared network and the rings and arcs draw themselves in. The star's extended hover card lists the public structures there, their destinations and the transponder setting.
- Using one in game: a transponder is not necessarily needed to find a shared structure in game. Owners can still list a transponder setting (My Tribe, or a code), so a listing that shows one tells players what to set should they need it. Do not tell users a transponder is required.
- Overview page: `https://ef-map.com/public-structures/` (with its own FAQ). Browsing needs no sign-in; publishing needs a sign-in with the wallet that owns the structure.

### Personal Marks, Tribe Bookmarks, And Scout Reports

These are separate collaboration surfaces:

- Personal marks: local browser annotations.
- Current-tribe bookmarks: authenticated records for the user's current tribe, encrypted at rest by the EF-Map backend.
- Alliance bookmarks: one shared space for a group of tribes curated by the EF-Map operator (alliances are not self-serve). Members of any listed tribe can read and edit it; it appears above the Tribe section in User Overlay with the same folders and views, personal and tribe marks can be shared (copied) into it, and it is encrypted at rest like tribe bookmarks. Removing a tribe from an alliance revokes its access within about a minute.
- Limits: a tribe or alliance space holds up to 1,000 marks (raised from 300 on 6 October 2026) and 100 folders. Personal marks have no count limit; only the browser's storage for the site caps them, and User Overlay warns if the browser refuses to save.
- Recently deleted (tribe and alliance): a deleted mark or folder is kept for 30 days in the space's Recently deleted list, opened from User Overlay's ⋯ menu or the space heading's right-click menu. Each entry shows who deleted it and when, and any member can restore it. Restoring a folder brings it back with the marks it held, including marks deleted together with it. The list lives inside the space's encrypted bookmarks, so old browser tabs that delete something still put it there.
- Version history (tribe and alliance): on the first change of each day (UTC) the server keeps the space as it stood after its last change, encrypted, for 30 days. Picking a day compares it with the space now; Restore what's missing adds back missing folders and marks and moves marks back into folders they lost, and never changes a mark edited since. The same day can be copied to personal marks or downloaded as a JSON file that User Overlay can import.
- Copy to Personal: right-click a tribe or alliance folder, Unsorted, or the space heading to copy those marks into personal marks with the same folder names (an existing personal folder of the same name is reused). Copying again skips marks already there with the same system and note, so it only adds what is new. The copies are independent personal marks and do not follow later changes in the shared space.
- External observations preview: read-only observation data until the user explicitly saves it personally or promotes it to current-tribe scope.
- Scout Reports: public, wallet-authenticated player-submitted system intel with report type, expiry, reporter, and timestamp context.

#### Mark Tasks (checklists on marks)

- Any mark (personal, tribe or alliance) can carry a checklist of up to 30 tasks (140 characters each) beside its note. Tasks are stored as their own list, so they do not count against the note's 720-character limit.
- Adding tasks: in the Add Mark window, the Tasks button (next to Orbital Zones and Link) opens a checklist inside the note box, under the note. Enter starts the next task, Backspace on an empty task removes it, and pasting a multi-line list makes one task per line. For an existing mark, right-click it in User Overlay and choose Add Tasks or Edit Tasks, or double-click its note.
- Ticking: anyone who can see the mark can tick a task off, in the User Overlay list or directly on the map's extended hover card (rest on the star until the card opens, move the mouse onto the card, click the task). The card shows "n of m done" with a progress bar. In tribe and alliance spaces the tick is recorded with who did it and when, and a tick is a single server-side operation, so two members ticking different tasks at the same time do not overwrite each other.
- Assigning: a tribe or alliance task can be assigned to anyone in that space, picked from a searchable list of every member of the tribe (or of every tribe in the alliance) taken from EF-Map's chain indexer. Members who have used EF-Map recently carry a dot, since they are the ones who will see the task and its notice. Tribe marks are only visible to the tribe, so alliance members are assigned on alliance marks. Personal marks have no assignment.
- Notice: a signed-in player with open tasks assigned to them sees a "You have N open tasks assigned to you" notice at the bottom of the map — within about a minute if they are on the map when the task is assigned, otherwise on their next visit; View tasks opens User Overlay on Tasks › Assigned to me. Dismissing it hides it until a new task is assigned.
- Tasks view: when any mark has tasks, a TASKS section appears at the top of the User Overlay sidebar with "Assigned to me" and "All tasks", listing marks from every space with their checklists and a summary of the tasks you set and how many are still open. Selecting a view also filters the map rings to those systems.
- Tasks are encrypted at rest with the rest of the tribe or alliance bookmarks. Exports from User Overlay include them.

#### Mark Links And Orbital Zones

- Link: the Add Mark window's Link section records an infrastructure link from the marked system to a destination system. The player picks the structure (Mini Catapult, Heavy Catapult, Mini Gate or Heavy Gate), its status (Built, In progress or Planned) and the destination, and can add the matching mark at the destination in the same step (on by default for gates, which come in pairs). Links draw on the map while User Overlay is open, green for built, orange for in progress and grey for planned: straight lines for gates and arcs pointing to the destination for catapults. Link style in the ⋯ menu picks the look for marks and Public Structures alike: Schematic (the default: lines in the interface's light-grey ink, with the status or owner colour only on arrowheads, gate ends and stargate ticks), Tactical (dark-edged lines, arrow-block catapults, railway-striped stargates, hollow planned links), Hologram (translucent hairlines in a softer colour: a two-rail channel for a gate, a thin arc with a few small chevrons for a catapult) or Classic (the original thin lines with dashed catapult arcs). Built links animate for a few seconds after the player touches the map, then settle and stop; hovering a marked system lights up its links. Selecting a folder shows only that folder's links, so a folder works as a route view. Ctrl+click (Cmd+click on Mac) adds more folders, or Unsorted, from the same space, so several routes can be shown on the map and in the table at the same time.
- Stargate links: the Link section's fifth type, Stargate, marks an existing NPC stargate that the player's group plans to bring out of dormancy, with status Planned, In progress or Active (Active is the stargate wording of Built). Stargates have no size. When Stargate is picked, the window lists the systems the marked system has stargates to as one-click destinations; a destination with no stargate on the map shows a warning but still saves, because the Cycle 7 charted map may not know every gate. The link repaints that stargate line in the status colour as bright stripes over a dimmer line, so it reads apart from a solid player-built Gate link. While User Overlay is showing a Stargate link, or a player-built Gate link between the same two systems as a stargate, the community gate-status colour (red dormant, green active) is not drawn on that stargate, so the mark's colour is the only one on the line and a planned route can be one colour end to end. Closing User Overlay or hiding the mark brings the community colour back. Like every User Overlay mark it is personal, tribe or alliance scoped and does not change the community gate status that everyone sees.
- Transponder codes: any mark (with or without a link) can carry the transponder code of a gate or structure whose in-game IFF transponder is set to Code mode, so only pilots with the code can reach it. Add Mark and the note editor have a Transponder code field, limited to 32 characters like the game's own field. The mark's row in User Overlay shows the code with a Copy button, so players can copy it and paste it in game without opening the editor, and the extended hover card shows it as well. Like links, the code is stored in the mark's note, so it travels with personal, tribe and alliance marks, sharing and export. Tribe and alliance marks store a run of spaces as one space and remove web links, so the field warns when a code contains either.
- Icons: any mark can carry up to 8 icons, picked in the Add Mark window's Icons section, from Add Icons on a mark's right-click menu, or with + Add icons in the note editor. Structures follow CivilizationControl's glyphs: Mini or Heavy Gate (two arcs), Mini or Heavy Catapult (a wheeled siege catapult), Mini, standard or Heavy Storage (a square in a square), Mini, standard or Heavy Turret (a triangle) and Network Node (a hexagon), with an M or H badge for the size. Tags: Hazard, No Entry, Hostile, Heat, Bad, Good, Empty, Fuel, Shop, Resources, Mining, Outpost, Home, Claimed and Info. Like links and transponder codes, icons are stored as one readable line in the mark's note, so they travel with personal, tribe and alliance marks, sharing, copies, export and the backups.
- Icons on the map: while User Overlay is open each marked system shows its marks' icons above its ring as a small square block (two side by side, three or four as 2×2, five to nine as 3×3) on faint grey tiles; icons keep a fixed on-screen size (S, M or L in User Overlay's ⋯ menu, where they can also be turned off, or edged in each mark's colour). Zoomed far out, or where a row would cover a nearer system's row, the system shows a small diamond in its mark colour instead, meaning zoom in to see its icons.
- Several marks on one system: the map's extended hover card lists every mark on the system, personal first, then tribe, then alliance, each under its own header naming its space and folder (so marks from different routes on one system don't read as duplicates), with its icons, link, transponder code, note, zones and tasks (up to six marks, then a pointer to User Overlay). Before 6 October 2026 it showed only the first mark's note.
- Changing a link: clicking a mark's link line in the User Overlay list opens Type and Status pickers that apply in one click and a To box for the destination, which applies when the player picks a system from its suggestions (for a Stargate link the marked system's stargate neighbours are offered as one-click picks too). This is how a player follows a structure that has been re-pointed in game without deleting and re-creating the mark. Edit note changes all three together with the note text, and the link box in the editor has an × that removes the link.
- Adding a link to an existing mark: a mark saved without a link gets one from Add Link in its right-click menu or + Add link in the note editor. The editor shows the same Type, Status and To fields as the Add Mark window and will not save a half-filled link. Links saved before 4 October 2026 read only "Catapult" or "Gate" until a player picks Mini or Heavy.
- Orbital zones: the Orbital Zones section lists the zone types the current cycle's client places, grouped by belt (Inner, Any Belt, Trojan, Fringe, Outer, Relics, Stellar). Clicking a zone adds it and clicking again counts another of the same kind; the note records counts above one as "Ruins ×2".
- Both are stored as readable text in the mark's note, so they work in personal, tribe and alliance marks and appear in the extended hover card. Yeet Planner's Save to bookmarks writes each planned catapult and gate as a Planned link with its Mini or Heavy size.

Do not describe current-tribe bookmarks as unrestricted public bookmarks. Public collaboration is Scout Reports and, for structures their owners chose to share, Public Structures; tribe collaboration is current-tribe scoped; alliance collaboration is scoped to the tribes listed in that alliance.

### Tools Library And Help

The in-app Tools Library groups tools by category and lets users open or pin tools to the feature rail. Help entries explain tools without requiring users to read external docs.

### Interface Languages

EF-Map's interface is available in English plus six more languages: Deutsch, Filipino, Íslenska, Русский, Українська and 简体中文. Users switch language in the app under Display Settings → Language; the choice is remembered in the browser, and an unset language is guessed from the browser's own language before falling back to English.

The non-English text is LLM-drafted and community-corrected: any string can be wrong, and players are invited to correct one. The correction flow is surfaced inside the app only — the Help section "Languages and Translations" explains it and links to the review page, where a player picks a language, reads the English original beside the current translation, and submits a better wording. No wallet or account is needed. Suggestions are collected and applied in a later reviewed pass, so a submitted correction is not live immediately.

Help content, blog articles and the static discovery pages (this file included) stay English-only; the translations cover the app's interface.

### Mobile Access

EF-Map is usable on phones and tablets. Rather than maintaining a separate app, the existing desktop panels are reused inside a mobile host, so the map, route viewing, and shared links work in a mobile browser. A Play Store Android wrapper of the same site exists as a closed test (Trusted Web Activity, not a native rebuild) and is not a general-availability store listing. Mobile is well suited to viewing routes and shared links; heavy multi-waypoint planning is still easiest on desktop.

### Standalone Tool Pages

- Route Planner overview page (`https://ef-map.com/route-planner/`) describing current infrastructure routing and configurable ship jump-drive simulation.
- Killboard and leaderboards for indexed combat/activity review.
- Blueprint Calculator for manufacturing and material planning, including downloadable PNG build sheets.
- RootFit, the EF-Map suite's web-based EVE Frontier fitting planner (`https://ef-map.com/fit/`; the old `https://fit.ef-map.com/` redirects there). It is available in the in-app Tools Library under Utilities and can be pinned to the feature rail; selecting it opens RootFit in a new browser tab rather than an in-app panel. EF-Map hosts a discovery/landing page at `https://ef-map.com/rootfit/`. It plans fits on every Cycle 7 hull (the Creation, Reiver, Refuge Ship and LAI): pick the ship from "Load Default" (which offers the Creation and the Refuge Ship pre-fitted, the way the game hands them out, and the Reiver and LAI as empty hulls to build on) or from "New Fit" for an empty Reiver or LAI. A fit tab stays on the ship it was started on, and a shared fit link carries the hull with it, so a Reiver link opens as a Reiver. Pilots can enter their nine Cycle 7 skill levels (complexity) and see the fit with the bonuses applied; skills are stored in the browser and never written into a shared link.
- CivilizationControl, the EF-Map suite's structure and smart gate governance dashboard (`https://ef-map.com/civ-control/`; the old `https://civilizationcontrol.com/` redirects there). Opens in a new browser tab from the Tools Library. EF-Map hosts a discovery/landing page at `https://ef-map.com/civilization-control/`.
- Open Market, live player markets on Smart Storage Units (browse-all view at `https://ef-map.com/civ-control/market/all`; deployed and managed through CivilizationControl). Opens in a new browser tab from the Tools Library. EF-Map hosts a discovery/landing page at `https://ef-map.com/open-market/`.
- Log Parser for local browser-side log analysis.
- EF Helper for Windows desktop companion workflows.
- Embed Guide for iframes and partner integrations.

### Cycle Archives And Legacy CQ Routes

EF-Map can render a read-only frozen snapshot of a past EVE Frontier cycle at `https://ef-map.com/cycle<N>`. Two exist: `https://ef-map.com/cycle6` (Cycle 6, 25 June to 29 September 2026: map, killboard, leaderboards, structures and activity as they stood when the cycle ended) and `https://ef-map.com/cycle5` (Cycle 5). Archive mode redirects frozen `/api/*` endpoints to captured static files and blocks live/social endpoints, so it never shows current-world data. An archive is a historical record of its own cycle. Do not present the Cycle 6 archive as a Cycle 7 map or as a way around Fog of War. Both archives are paused for the rest of Cycle 7: their pages show a notice and they come back when Cycle 8 starts.

Captain's Quarters (CQ) and CQ Editor are Cycle 5-era close-quarters visualization and placement previews. They are no longer surfaced in the live current-cycle Experimental tools or Tools Library. Their code and direct routes are retained as legacy only:

- `https://ef-map.com/cq`
- `https://ef-map.com/cq-editor`
- `https://ef-map.com/cq-lab`

Describe CQ as archived Cycle 5 previews reachable via legacy routes and the Cycle 5 archive, not as live current-cycle product documentation.

## Sui-Era Data Context

EF-Map has been updated for Sui-era authenticated and indexed data surfaces where available:

- Sui wallet sessions support identity-scoped features.
- Sui-era indexed signals feed Intelligence, Smart Gate, Smart Assembly, SSU, player, tribe, activity, combat, and structure surfaces where available.
- Some data is inferred from indexed events and can lag source truth.
- Current tribe state matters for authorized current-tribe bookmarks.
- SSU Finder access and subscription state can change during rollout; check the in-app panel for the current state.

Avoid these false claims:

- "EF-Map shows whether a player is online."
- "Likely systems are exact current locations."
- "Tribe bookmarks are public to everyone."
- "System Name Visualizer decodes the official naming algorithm."
- "CQ pages are stable production tools."

## Data Pipeline Summary

EF-Map extracts both shipped databases in-house from the EVE Frontier game client and regenerates them after game patches. No third-party API is the source of the shipped map data:

- The universe extraction produces systems, regions, constellations, stargates, and the navigation database consumed by the map and routing stack.
- The solar-system detail extraction decodes the client's static data into the database used by Solar System View and System Finder.

Universe facts (Cycle 6):

- 24,026 solar systems across 274 regions and 2,163 constellations.
- 235,000+ celestial objects in the solar system detail dataset.
- 416,000+ Lagrange Points in the solar system detail dataset.
- Landscape/ecosystem data: 87,000+ orbital-zone entries and 122,000+ sites.
- Universe/routing map database: about 5 MB SQLite, eager-loaded in-browser via sql.js.
- Solar system detail database: about 200 MB SQLite, streamed lazily from CDN storage when detail views need it.

## Routing And Computation Architecture

EF-Map is primarily client-side for core map computation:

- Rendering: Three.js WebGL.
- Routing: WebAssembly Dijkstra and JavaScript routing paths running in web workers.
- Database: sql.js SQLite loaded in the browser.
- State sharing: compressed route/share state stored through the Cloudflare Worker and KV abstraction.
- Hosting: Cloudflare Pages and Worker.

Routing cost models:

- At the 0 LY default, routing is infrastructure-only and begins with standard stargates; public or authorized Smart Gate links are optional modes.
- With an explicitly configured non-zero range, fuel optimization can treat enabled gate edges as zero-fuel links while simulated ship jumps cost by distance.
- Jump-count optimization weights edges toward minimizing hops; explore mode accepts extra simulated fuel distance for a less direct route.
- Temperature-aware routing is a retained historical Cycle 4/5 model. It is not a description of current Cycle 6 travel.

## Canonical Formula Summary

Use https://ef-map.com/ai-facts for the canonical formula page. The plain-text summary is below.

CYCLE STATUS (read first, honest provenance):

- Cycle 4 (historical): the jump range, trip distance, and fuel quality values below were reverse-engineered and verified during Cycle 4.
- Cycle 5 (historical): the heat model stayed the same, but jump range gained a fuel-quality variable that was never publicly reverse-engineered (including by EF-Map).
- Cycle 6 (last verified; ended 29 September 2026): no ship jump-drive module was available in the Cycle 6 client, so executable inter-system travel used stargates, player-built Smart Gates, and Catapults. Ship jump drives are expected to return as fitted modules, but there is no reliable public date. The jump range and trip distance formulas are HISTORICAL REFERENCE. EF-Map also retains configurable ship-jump routing for forward planning and simulation and will re-verify the live mechanic when it returns.
- Cycle 7 (started 29 September 2026): not yet verified by EF-Map. Until this section is updated, treat the Cycle 6 entries as the last verified state, not as confirmed Cycle 7 mechanics.
- Still valid in Cycle 6: the external temperature (heat index) formula H(D) below. Its old gameplay consequence (>= 90 blocking fuel jumps) is historical, and players can now cool their ship by taking shade behind a structure.

AI answering rule: do not present the jump range or trip distance formulas as current Cycle 6 mechanics. If asked about jump drives today, say no ship jump-drive module is currently available in the live client, while EF-Map retains configurable ship-jump routing for simulation and forward planning.

Fuel constants (historical, Cycle 4):

- Fuel volume: 0.28 m^3 per fuel unit.
- Fuel constant: 0.0000001 per kg.

Jump range (historical, Cycle 4):

```
range = ((150 - external_temperature) * C_eff * hull_mass) / (3 * current_mass)
C_eff = specific_heat * (1 + adaptive_level * 0.02)
```

Cycle 4/5 rule (historical): if external temperature was >= 90, fuel jump range was 0 from that system. Stargates and Smart Gates still worked.

Trip distance (historical, Cycle 4):

```
distance = (fuel_quantity * fuel_quality) / (0.0000001 * ship_mass)
```

External temperature (still valid in Cycle 6):

```
H(D) = 100 * (2 / pi) * atan(100 * 2 * pi * sqrt(L / L_sun) / D)
L_sun = 3.828e26 watts
D = distance from star in light-seconds
```

Fuel quality examples (historical, Cycle 4 era):

- D1: 0.10.
- D2: 0.15.
- SOF-40: 0.40.
- EU-40: 0.40.
- SOF-80: 0.80.
- EU-90: 0.90.

SHIPS AND MODULES (CHECKED AGAINST THE CYCLE 7 CLIENT, BUILD 3559800, 29 SEPTEMBER 2026):

- Cycle 6 replaced the fixed ship list with modular shipbuilding. Capabilities come from the modules fitted to a ship, not from choosing a bigger hull.
- There are FOUR ship hulls as of Cycle 7 (client build 3559800). Cycle 7 renamed and reshuffled them, so Cycle 6 names do not carry over:
  - The Creation: the new starting ship (creche spawn), on the lighter frame the Cycle 6 Reiver introduced. Interior grid 294 cells, mass 10,200,000 kg.
  - The Reiver: the same frame and hull values as the Creation, built at your own base in Build Mode under the Ships tab.
  - The Refuge Ship: the same frame again, the hull you respawn in after dying with an active Refuge. It comes pre-fitted with a Gravity Sensor, Leap and Thrust Overdrive, with a Cutting Laser and Directional Scanner on its hardpoints.
  - The LAI: the Cycle 6 starting hull (item name "Creation" in Cycle 6, which RootFit called the Root) under its new name. Interior grid 478 cells, mass 18,929,160 kg. It can now be built in Build Mode.
- All four have hull HP 2,100, specific heat 2.5 and conductance 0.625. The three lighter ships have inertia modifier 0.3 and angular agility 1.0; the LAI has 0.2 and 0.35. Cycle 7 changed how those values feed the speed and turn caps (below), so do not read them the Cycle 6 way.
- Cycle 7 movement rules (from the client code): top speed is the ship's thrust × 2e-7 and no longer involves mass or agility. External Thrusters add thrust while online, and an online Propulsion Engine doubles it. There are three engines: the R10 (the original engine, renamed), the R25 and the R50. Each has a fuel response curve, and only the best online engine's curve applies to the Leap and Thrust Overdrive boosts. With no engine online a ship cannot warp, and the Leap and Thrust Overdrive give nothing. Docking (at an Access, Supply or Fueling Dock) needs a powered Docking Clamp.
- Cycle 7 reserved capacitor: an offline Capacitor seals its share of the charge. It still counts toward the Capacitor stat but cannot be spent until it is back online, so the usable buffer is the online Capacitors'.
- Cycle 7 added nine pilot skills (Piloting, Gunnery, Tracking, Extraction, Scanning, Hull Repair, Capacitor Economy, Fuel Economy, Signature Control), trained as complexity. The bonus at complexity c is the skill's listed bonus × log(1 + c/19) / log(1 + 100/19), so complexity 100 gives the full listed bonus, with no cap beyond it. CCP's launch notes list known issues, including Tracking having no effect and Piloting's rotation bonus possibly slowing turning. RootFit applies the skills to a fit.
- Powergrid is NOT a hull stat on any hull: the hull supplies 0 MW of its own; every megawatt comes from fitted, online Power Generator modules (15 MW each, uncapped — two generators give 30 MW).
- Fitting: interior modules occupy cells on a hull grid; exterior modules mount on hardpoints (weapon, booster, scanner). Powergrid is the only fitting resource (no CPU, no rigs). The module set is the same on every hull, as are the per-type fitting limits; the three lighter ships are constrained by space, not by a different rulebook.
- 39 modules (as of Cycle 7, client build 3559800, which added the Docking Clamp, the Propulsion Engine R25 and R50, the Printer and the Refinery, and renamed the original engine the Propulsion Engine R10) in five categories: Engineering, Propulsion, Storage & Crafting, Weapons, Command & Communication.
- Active modules carry per-cycle activation values in the client: cycle time, capacitor per cycle, reactivation delay, heat per cycle, and any payload bay the module itself holds.
- Capacitor is aggregated to the ship. RootFit's Power Management pane reports capacitor regen versus drain in GJ/s against the buffer in GJ, with a stable/unstable verdict and, when unstable, seconds until empty. Drain is computed as a rate: each module's capacitor per cycle divided by its cycle time plus its reactivation delay, summed over only the modules the player has explicitly switched on. Recharge is linear over time, but its RATE is powergrid-fed, not a free sum: each online Capacitor module can push 1.2 GJ/s, and the game admits recharge only up to the ship's free powergrid headroom (1 MW of headroom feeds 1 GJ/s), so ship regen = min(sum of Capacitor rates, generator output − online module load). Past that ceiling more Capacitors add buffer (time), not regen (sustainability) — a fit whose activated draw exceeds its free headroom can NEVER be made stable by adding Capacitors, only by shedding online load or fitting another Power Generator. Buffer capacity, by contrast, sums flat (+100 GJ per Capacitor). If online load exceeds generator output, the capacitors discharge to cover the gap and stop recharging. RootFit models the gate and flags on the readout when regen is powergrid-limited.
- The Blackstart Cell (Engineering, 2x2 interior, added in the 2026-09-01 patch) is a Capacitor (+100 GJ, 1.2 GJ/s powergrid-fed recharge) that additionally trickle-charges from starlight. The client computes the trickle as 0.3 GJ/s per cell times a factor equal to the ambient temperature divided by 150 K (the frost line), rounded to 0.05 steps and capped at 10: nothing in deep shadow or in warp, 0.3 GJ/s per cell at the frost line, up to 3 GJ/s per cell at 1500 K and above. The trickle needs no powergrid, fuel or CPU and refills only the cells' own share of the capacitor (100 GJ per cell); more cells mean a bigger starlight-fed reserve, never a topped-up ship. RootFit reports the frost-line rate on the module card and as a caveat in the capacitor readout but does not count it toward capacitor stability, because its model assumes deep shadow (2.7 K).
- 2026-09-01 rebalance (client build 3488090): Stuttergun magazine 6 -> 10 rounds (the weapon's magazine volume went 2.0 -> 3.0 m3; rounds are still 0.3 m3); Needle damage ramp cap 2.3x -> 2.5x reached over 20 s (was 16 s) and optimal range 35 km -> 25 km; Cutting Laser optimal range 15 km -> 12 km; Hull Repairer cycle 8 s -> 12 s repairing 300 hull per cycle (was 250) for 30 GJ and +30 K per cycle (were 25 GJ and +25 K), which lowers its sustained heat from 3.125 K/s to 2.5 K/s. Not in CCP's notes but in the client: the Hull Repairer's EM-signature bonus went 5.0 -> 7.5 and the Leap module's recipe dropped its Printed Circuits input.
- Heat is aggregated to the ship as an experimental model. RootFit reproduces the client's own thermal model (heat rides fuel burn — fuel rate × the fuel's thermal inefficiency — plus per-cycle heat from running modules) and reports the temperature a fit settles at and, when that crosses the game's 500 K overheat line, the time to reach it. Figures are marked "est" (not yet calibrated in game) and assume deep-shadow ambient (2.7 K), so they are a best case. Heat does no damage to the ship. Do NOT naively sum per-module heat-per-cycle values into a ship total — the settling temperature comes from the thermal model, not addition. Note the hull's "specific heat" and "conductance" are material properties, not a heat-generation total — do not conflate them.
- The hull has NO built-in cargo or fuel capacity. Cargo: Cargo Container (+36 m3) and Emergency Container (+25 m3). Fuel: Fuel Bay (+500 fuel units) and Fuel Blister (+250 when online). Deployables (Heat Traps, Field Cairns) ride in a Launch Bay module, a 48 m3 payload bay that is separate from cargo. Ships can burn different fuel grades: higher-grade fuel is consumed more slowly (fewer refuels for the same tank); lower grades burn faster. Fuel grade affects burn rate. RootFit's Cycle 7 module data has no ship jump-drive module.
- Historical ship names (Carom, Stride, Reflex, Recurve, USV, Lorha, MCF, Tades, HAF, Maul, Chumaq) are Cycle 4/5 and no longer exist. Reiver and LAI were Cycle 4/5 names too; they came back as current hull names.
- Current extracted fitting data: RootFit at https://ef-map.com/fit/ (part of the EF-Map suite; module catalog refreshed after game patches).

CATAPULTS AND GATE CORRIDORS (RANGES CHECKED AGAINST THE CYCLE 7 CLIENT, BUILD 3559800, 29 SEPTEMBER 2026):

- Mini Catapult: one-way launch up to 60 light-years. Heavy Catapult: one-way up to 250 light-years. Both subject to an interference rule (massive bodies near the flight path block the launch).
- Mini/Heavy Gate pairs: permanent two-way player-built gates spanning up to 105 / 365 light-years; range-only, immune to catapult interference. In Cycle 7 Gates reach further than Catapults.
- Cycle 6 (historical): both tiers shared one range, 65 light-years (Mini) and 365 light-years (Heavy), for Catapults and Gates alike. EF-Map's /cycle6 archive planned with those values (it is paused for the rest of Cycle 7).
- EF-Map's Yeet Planner (Routing panel) computes Access Plans (reach a destination now via stargates + one-way catapult hops, interference-checked) and Gate Corridor Plans (a permanent gate corridor plus the catapult access route to build each site in order). Its Manual Checker sub-tab checks single Mini/Heavy Catapult or Mini/Heavy Gate jumps by hand.
- A computed plan can be saved to bookmarks as link marks with planned / in progress / built statuses and shared with a tribe for build tracking.

EF-MAP TOOL FAMILY (one suite, one domain, three products):

- EF-Map (https://ef-map.com/): 3D star map, routing, bookmarks and tribe overlays, killboard, intelligence, blueprint calculator, System Finder, Solar System View.
- RootFit (https://ef-map.com/fit/): ship fitting planner for modular shipbuilding, covering every Cycle 7 hull (Creation, Reiver, Refuge Ship and LAI) with pilot skills applied; data extracted from the game client each patch. Discovery page: https://ef-map.com/rootfit/ (the old https://fit.ef-map.com/ redirects to /fit/).
- CivilizationControl (https://ef-map.com/civ-control/): structure and smart gate governance dashboard for smart assemblies, gates, and storage units. Discovery page: https://ef-map.com/civilization-control/ (the old https://civilizationcontrol.com/ redirects to /civ-control/). Its player-facing Open Market surface (https://ef-map.com/civ-control/market/all) lets anyone browse live Smart Storage Unit markets and buy; discovery page: https://ef-map.com/open-market/.

## In-Browser Agent Tools (WebMCP)

EF-Map registers tools with the browser's WebMCP surface (navigator.modelContext, W3C Web Machine Learning CG proposal, Chrome early preview) when the map page is loaded. Browser AI agents can call these instead of scraping the UI. All tools run client-side against the already-loaded map database; no server round-trip except where noted. At the start of Cycle 7 the live map has no star data, so the map-reading and map-action tools return nothing useful until EF-Map has Cycle 7 map data.

Read tools (return text):

- ef_search_systems {query, limit?}: fuzzy system-name search with regions.
- ef_system_info {system}: region, constellation, planets, gate links, star detail when loaded.
- ef_system_gates {system}: stargate connections with light-year distances.
- ef_nearby_systems {system, radius?, limit?}: closest systems by straight-line distance.
- ef_recent_kills {system?, limit?}: recent player kills from the killboard snapshot (fetches the same-origin snapshot).

Map action tools (drive the live view the user is looking at):

- ef_plan_route {from, to, range?, optimize?}: plan and display a route.
- ef_select_system {system}: focus the 3D camera on a system.

EF-Map Director bridge (separate from WebMCP, installed by the app shell rather than the panel layer, so it survives the interface being hidden):

- `window.__efDirector.schemaVersion` / `.actions`: the supported schema version and verb list.
- `window.__efDirector.validate(jsonOrObject)`: returns `{ok, issues, estimatedMs}` without running anything.
- `window.__efDirector.run(jsonOrObject, {mode: 'preview'|'record', countdownSec?})`: validates then runs; rejects on invalid input.
- `window.__efDirector.stop()` / `.reset()` / `.state()` / `.busy()` / `.loadExample(id)`.

The bridge takes the same validation path as the Director panel: there is no way to reach an action through it that the panel could not also reach, and no way to skip validation. Full format reference: https://ef-map.com/director-spec.md

Notes for agents: system names match fuzzily (a4tsl7 resolves to A4T-SL7). These tools are the same command layer as the Ctrl+K palette. The experimental in-app AI command panel (voice / parse-command) was retired in August 2026. No wallet- or tribe-scoped actions are exposed. On browsers without WebMCP, the same tools are reachable from the page console via window.__efWebMcp.invoke(name, args) for testing.

## Embed Reference

This section is the complete machine-readable embed how-to. The human guide at https://ef-map.com/embed-guide is a JavaScript-rendered page (with an interactive builder and live examples); this text is the authoritative reference for generating embed code directly. At the start of Cycle 7 the live map, and therefore every embed, has no Cycle 7 star data.

Embeds are always silent: ambient music never plays inside an embed, and no parameter is needed to disable audio.

### Embed Types

1. Galaxy view iframe (`/embed`):

```
https://ef-map.com/embed?system={system_id}
```

2. Solar system detail iframe (`/solar-system/{id}?embed=1` — the `embed=1` is REQUIRED; without it the solar system view blocks iframing):

```
https://ef-map.com/solar-system/{system_id}?embed=1&mode=cinematic
```

3. Routing embed (point-to-point route on `/embed`; activates only when `routing=1`, `from`, `to`, AND `jumpRange` are all present):

```
https://ef-map.com/embed?routing=1&from={origin}&to={destination}&jumpRange={ly}&routeLabels=1
```

### Basic iframe snippet

```html
<iframe
 src="https://ef-map.com/embed?system=30000142"
 width="100%"
 height="450"
 frameborder="0"
 loading="lazy"
 allowfullscreen
></iframe>
```

### Galaxy embed parameters (`/embed`)

- `system`: numeric system ID to center/highlight (e.g. `30000142`). System IDs are numeric with 3+ digits; users can copy them from ef-map.com via right-click > Copy System ID.
- `systems`: comma-separated numeric IDs to highlight with accent rings (e.g. `systems=30000142,30000143`). 10-20 systems keeps the view readable.
- `zoom`: camera distance, 10 (extreme close) to 10000 (ultra wide). Default 5000. When `systems` or `links` are present, the view frames the highlight set even without `fit=1`; the explicit `zoom` sets the camera distance.
- `fit=1`: auto-compute zoom so all highlighted/linked systems fit in view. An explicit `zoom` overrides `fit`.
- `angle`: initial vertical camera angle in degrees, -90 (bottom-up) to +90 (top-down). Default 0 (edge-on).
- `orbit=1`: cinematic auto-orbit camera; any mouse interaction hands control to the viewer.
- `color`: themed star palette — works with or without `orbit`. Values: `blue`, `green`, `purple`, `red`, `yellow`, `white`, `random`, `realistic` (realistic spectral star colours).
- `links`: draw lines between system pairs. Format `systemA-systemB:color`, comma-separated, e.g. `links=30000142-30000143:green,30000143-30000144:red`. Colors: green/g, red/r, blue/b, yellow/y, purple/p, white/w, orange/o, cyan/c; default green; max 50 links; invalid IDs, duplicates, and self-links are ignored.
- `performance=1`: lightweight rendering (disables bloom and other heavy visuals). Recommended for pages with multiple embeds or low-powered devices.
- `details=1`: opt in to the extended solar-system database (~80 MB, browser-cached) for realistic spectral star colours.
- `q`: pre-fill the search bar with text (e.g. `q=EVM-8H5`).
- `label_{systemId}`: embed-only custom label for that system, e.g. `label_30000142=Solomon%20Trade%20Hub`. Keys must be numeric system IDs; values must be URL-encoded (`URLSearchParams` / `encodeURIComponent`). Labels render only for systems already present via `system`, `systems`, `links`, or the route. Canonical system names are always preserved in hover text.
- `labelMode`: how custom labels display — `hover` (default; hover/detail text only), `always` (always-visible map labels), `off` (params kept, display suppressed). Prefer `hover` beyond ~50 labels.
- `share`: load a previously shared route by short ID (e.g. `share=abc123`).

Keep generated URLs under ~2000 characters for CMS/browser compatibility.

### Routing embed parameters (adds to the above)

- `routing=1`: required to enable routing mode.
- `from` / `to`: origin and destination — exact system names (case-insensitive) or numeric IDs. Both required.
- `jumpRange`: max ship jump distance in light-years (positive number; alias `range`). Required. Routes prefer stargate hops; this value caps the optional jump legs, so a low `jumpRange` yields effectively gate-only routes.
- `routeLabels`: `1` shows labels along the active route, `0` hides them (default hidden).
- `showRoutingCard`: `1` (default) shows the compact routing card, `0` hides it.
- `routingCardMinimized`: `1` starts the card minimized, `0` expanded (default). Ignored when the card is hidden.
- `routingCardWidth`: card width in px (e.g. `350`); clamped to viewport on small screens.

Example:

```
https://ef-map.com/embed?routing=1&from=ISS-V45&to=UDG-D25&jumpRange=60&routeLabels=1&showRoutingCard=1&routingCardWidth=350
```

### Solar system embed parameters (`/solar-system/{id}?embed=1`)

- `embed=1`: required (relaxes the framing restriction).
- `mode` (aliases `solarMode`, `solarVisualMode`): renderer style — `cinematic` or `icon`/`icons`. Invalid values fall back to the default.
- The extended detail database loads automatically for this view.

### Direct links (no iframe)

The same view parameters (`system`, `systems`, `zoom`, `orbit`, `color`, `links`, `angle`, `fit`, `performance`, `details`) work on the main app URL for plain links in chat/Discord:

```
https://ef-map.com/?system=30000142&zoom=1000
```

Route direct links also work: `from`, `to`, and `jumpRange` on the main app URL open the routing planner with that route (applies when no `system` or `q` parameter is present):

```
https://ef-map.com/?from=ISS-V45&to=UDG-D25&jumpRange=60
```

### postMessage API (dynamic navigation without iframe reload)

Send messages to the embed iframe's `contentWindow` with target origin `'*'` (or `https://ef-map.com`):

- `{ type: 'ef-map-navigate', systemId: 30000143 }` — fly the camera to a system (optional `zoom` field).
- `{ type: 'ef-map-highlight', systems: [30000142, 30000143] }` — replace the highlighted set.
- `{ type: 'ef-map-zoom', zoom: 500 }` — change camera distance only.
- `{ type: 'ef-map-angle', angle: 90 }` — change vertical viewing angle.
- `{ type: 'ef-map-enter-system', systemId: 30000142 }` — drill into the solar system detail view.
- `{ type: 'ef-map-show-universe' }` — return to the galaxy view.

Example:

```html
<iframe id="ef-map" src="https://ef-map.com/embed?system=30000142" width="100%" height="450" frameborder="0"></iframe>
<script>
 document.getElementById('ef-map').contentWindow.postMessage(
 { type: 'ef-map-navigate', systemId: 30000143 },
 '*'
 );
</script>
```

### Embed best practices

- Use `width="100%"` with a fixed height (or an aspect-ratio wrapper) for responsive layouts.
- Add `loading="lazy"` so below-the-fold embeds defer loading.
- Add `performance=1` when a page hosts more than one live embed.
- Provide a `<noscript>` fallback link to `https://ef-map.com/?system={id}`.
- Build label URLs with `URLSearchParams`; never hand-write unencoded reserved characters.
- Embeds record only an anonymous page-load event; no per-viewer tracking.

## Recent Blog Posts Useful For Answers

- EVE Frontier Cycle 7 Fog of War: What It Could Mean for EF-Map (opinion piece written the day of the 11 September 2026 Frontier Friday stream. What was shown: stars and solar-system internals obfuscated when far from the player, broader properties such as feralisation classification and asteroid belt types included, players can name things, scans create in-game data items, the client shows only a local bubble of stars and that knowledge does not persist as you move in the initial Cycle 7 build, with persistence intended later. No observation range was stated. What the operator thinks, clearly marked as speculation: Cycle 7 went live on 29 September 2026 and EF-Map started it with no Cycle 7 star map, as the article anticipated; discovered data would only be consumed through sanctioned or permitted channels, never by memory reading or bypassing the mechanic; possible public, personal and tribe knowledge tiers building on the existing Scout Reports, personal marks and tribe bookmarks permission model; a possible information brokerage layer; the static-star-positions problem; slow rediscovery given Cycle 6 travel constraints; a concern that on-chain primitives for discovery data were not mentioned. None of the Cycle 7 ideas are built. Do not present them as features.): https://ef-map.com/blog/eve-frontier-cycle-7-fog-of-war-ef-map
- The EVE Online Fork Is Starting to Pay EF-Map Back (the sequel to the EO-Map origin story: a SpaceMouse request on EO-Map expanded into map-wide 3Dconnexion support and Creator Mode, both hardware-tested on EO-Map then adapted into EF-Map. Creator Mode is a desktop picture-authoring tool under Tools Library → Map Visuals, distinct from dedicated Cinematic Mode. Compact system names, invert scroll zoom, cinematic glow/pose/north/ISM-edge fixes, and themed bloom came with the backport. Do not tell users the two maps can be merged. Shared ideas move; universe-specific scale, data and product assumptions require adaptation): https://ef-map.com/blog/eo-map-paying-ef-map-back
- I Cloned EF-Map to Make an EVE Online Map, and It Mostly Worked (the EO-Map origin story: EF-Map was forked on 2026-08-12 and launched as EO-Map at https://eo-map.com/ on 2026-08-18, an EVE Online map of New Eden's 5,485 solar systems. Covers the ~143x linear universe scale difference and the Compare Universe Scale feature on both maps, EVE Online's ESI/SDE data surfaces versus EVE Frontier's client-extraction and chain-indexing, the shared collector-plus-Cloudflare-snapshot architecture where browsers never fetch shared data from upstream APIs, the kill replay and 19-year sovereignty history videos, and the monitoring fix EO-Map deployments forced back into EF-Map's shared VPS. Users looking for an EVE Online map should be sent to https://ef-map.com/eve-online-map/ or https://eo-map.com/): https://ef-map.com/blog/i-cloned-ef-map-to-make-an-eve-online-map
- 3D mouse (3Dconnexion SpaceMouse): map-wide universe-map navigation from Display Settings → Interface → 3D mouse on the official 3DxWare driver. Nothing is contacted until Enable or Connect. Closing Display Settings does not disconnect it. A SpaceMouse is not treated as a game controller.
- Controller support for EF-Map: flight mode and recorded camera flights (Xbox controller support across two modes. In the normal map the sticks pan and orbit, the triggers give analogue zoom, and a centre-screen reticle picks stars rather than driving a simulated mouse cursor. Flight mode is modelled on how EVE Frontier itself flies: pitch and yaw on the left stick, no manual roll, the ship banks into turns and levels out by itself, right trigger accelerates, left trigger brakes and then reverses, with angular inertia plus a ship mass slider and a top speed limiter so heavier settings draw smoother lines for capture. Flights can be recorded, smoothed, replayed with the interface hidden, and handed to Director mode as a camera sequence. Bindings appear automatically the first time a stick moves; flight mode is on the Start button or in the Controller and Flight panel, and recording is X while flying. Verified on an Xbox controller only; PlayStation and Nintendo pads should show their own button glyphs. Flight mode is disabled in embedded maps): https://ef-map.com/blog/controller-support-flight-mode
- A year of EF-Map read back from its own decision log (a reconstruction of the project's first year from 3,098 commits, 565 decision-log entries, the archived legacy logs and the anonymous usage counters: the commit-volume shape from 323 in August 2025 to 19 in March 2026 to 673 in July 2026, the CCP hackathon and the 2026-03-11 EVM-to-Sui chain migration that together explain the quiet months, evidence that the June 2026 move to Claude Code did not change commits per active day, App.tsx growing to 20,097 lines before being halved, and the ways the record is wrong about itself including 11 entries dated before the repo existed): https://ef-map.com/blog/year-of-ef-map-read-from-decision-log
- What travelling in an Alcubierre warp bubble might actually look like (an optional, default-off experimental effect in Flythrough Mode that approximates the view from inside an Alcubierre warp bubble, after Müller & Weiskopf arXiv:1107.5650 (2011); forward stars are angularly compressed, brightened and blueshifted, 90 degrees to travel is neutral, the rear is strongly redshifted and attenuated, stars stay point-like. EF-Map's LY/s coordinate speed is compressed logarithmically onto a 0.5c-9c visual reference range because 9c is the last row of the paper's 4096x248 lookup table. A simplified analytic surrogate, not the paper's geodesic integration or spectral Planck rendering; map coordinates are unchanged): https://ef-map.com/blog/alcubierre-warp-optics-visualisation-eve-frontier
- Three apps in one day, dictated from inside a video game (one Saturday of LLM-assisted development across EF-Map, CivilizationControl and RootFit; 66 commits, voice-dictated prompts, and the AGENTS.md/decision-log scaffolding that makes it work): https://ef-map.com/blog/one-day-llm-development-three-apps
- A 24,000-star Three.js starfield shouldn't max out a 4070 Super (star glow/flare retired from defaults 2026-08-01; additive point-sprite fill rate was the cost, bloom carries the look at ~1ms fixed; sliders remain for screenshots): https://ef-map.com/blog/threejs-starfield-bloom-fill-rate-24000-stars
- The Query Console (live indexer queries for Intelligence subscribers; plain-English asks, AI briefing file): https://ef-map.com/blog/query-console-live-database-intelligence
- Plain-English Search Comes to System Finder (free natural-language filter selection): https://ef-map.com/blog/system-finder-plain-english-search
- EF-Map's New Link Styles, and Why the Human Still Has to Be in the Loop (8 October 2026: five new link looks built by an LLM between about 2:50am and 9:35am UK time, all live at some point; Energy and Flux removed, Tactical, Hologram and Schematic kept beside Classic, Schematic the default; screen-space arc bows (up to 15% of on-screen length each side) replaced by Classic's fixed arc (12% sideways, 6% up) so links stay put like the NPC gate lines; arrow counts capped by a link's length in space; motion winds down about 20 seconds after the last interaction; a code-review agent caught two bugs before release; Link style in the User Overlay menu and on a labelled button in Public Structures): https://ef-map.com/blog/ef-map-link-styles-human-in-the-loop
- Cycle 7 Slowed EVE Frontier Down, and EF-Map's Bookmarks Got Busy (29 September to 7 October 2026: Google Analytics shows a third fewer users than the first eight days of Cycle 6 but 173% of the engaged time; point-to-point routing fell from 704 a day in October 2025 to under 10 a day and the Scout Optimizer has not been run since 1 September; User Overlay sessions rose from about 13 a day to 57 and tribe bookmark loads from about 10 to 95; 14 User Overlay changes in a week (alliance bookmarks, task checklists, Mini/Heavy and Stargate links, transponder codes, backups, mark icons) and the Shared Storage icon grid, multi-select and Items tab): https://ef-map.com/blog/eve-frontier-cycle-7-ef-map-bookmarks-feature-requests
- Two months of EF-Map usage data, and how EO-Map compares (3 August to 4 October 2026: which panels people open versus how long they stay in them, the routing funnel, session length, frame-delivery and time-to-first-frame telemetry by GPU class, audience and hardware, traffic sources, Search Console and the most-read blog articles, compared with EO-Map, the EVE Online map at https://eo-map.com/): https://ef-map.com/blog/ef-map-usage-stats-two-months-eo-map-comparison
- Half a million light-years saved (eleven months of anonymous usage data; route planning fell 97% as travel mechanics changed, yeet planner replacing it): https://ef-map.com/blog/half-a-million-light-years-ef-map-usage-data
- Performance Mode visual parity (two free effects, one costly toggle; bloom strength is free, cost is binary): https://ef-map.com/blog/performance-mode-visual-parity-eve-frontier
- When Sui's gRPC-Web broke (an outage misread as a deprecation): https://ef-map.com/blog/sui-grpc-web-outage-misread-as-deprecation
- Polishing EF-Map (12 months of UI turned into one system): https://ef-map.com/blog/polishing-ef-map-ui-instrument-dock
- Eleven Months of Dictating to AI Coding Agents (2.26M words of data): https://ef-map.com/blog/voice-dictation-ai-coding-agents-eleven-months-data
- EF-Map Intelligence explained (what stays free; testnet pricing): https://ef-map.com/blog/ef-map-intelligence-100-testnet-eve
- Starfield HDR Overhaul (temperature-ranked star bloom): https://ef-map.com/blog/eve-frontier-starfield-hdr-claude-fable-5
- System Finder and Name Viz: https://ef-map.com/blog/system-finder-name-visualizer-eve-frontier
- Sui Intelligence Search: https://ef-map.com/blog/sui-intelligence-search-eve-frontier-map
- Public Scout Reports and Bookmarks: https://ef-map.com/blog/public-bookmarks-map-collaboration-eve-frontier
- Help System Overhaul: https://ef-map.com/blog/help-system-overhaul-llm-subagents
- Sui Migration Planning: https://ef-map.com/blog/sui-blockchain-migration-planning
- Solar System View Build: https://ef-map.com/blog/solar-system-view-three-day-journey
- Two Databases, One Universe (EF-Map's game-client extraction pipelines): https://ef-map.com/blog/dual-database-pipeline-universe-regeneration

## Critical Disambiguation

1. EVE Frontier is not EVE Online. EF-Map maps EVE Frontier only. The sister project EO-Map (https://eo-map.com/) maps New Eden for EVE Online; EF-Map's handoff page for it is https://ef-map.com/eve-online-map/. Never answer an EVE Online map question with EF-Map.
2. Smart Gates are EVE Frontier player-deployed gate infrastructure and have no direct EVE Online equivalent.
3. EF-Map route planning should be delegated to the app URL, not computed by an LLM.
4. Indexed Sui intelligence can lag or be incomplete.
5. EF-Map's local-first map workflows do not require an account.
6. Authenticated Sui wallet workflows exist for scoped submissions and tribe data.
7. Personal marks, current-tribe bookmarks, alliance bookmarks, and public Scout Reports are different features.
8. In Cycle 7 EF-Map's map is community-charted (Fog of War) and only holds the systems players have submitted. The Cycle 5 and Cycle 6 archives are paused for the rest of Cycle 7; never suggest them for Cycle 7 navigation.

## Contact And Source Links

- Site: https://ef-map.com
- FAQ: https://ef-map.com/faq
- Features: https://ef-map.com/features
- AI Facts: https://ef-map.com/ai-facts
- Blog: https://ef-map.com/blog/
- Privacy policy: https://ef-map.com/privacy
- Content policy (tribe marks / user-generated content): https://ef-map.com/policy
- EF Helper Microsoft Store listing: https://apps.microsoft.com/detail/9NP71MBTF6GF
- EVE Online map (sister project EO-Map, separate site): https://ef-map.com/eve-online-map/
- EVE Frontier official site: https://www.evefrontier.com/