What your site serves
Besides its pages, a CTXR site answers on a fixed set of addresses: the files the web expects from any site, the views CTXR adds for assistants and readers, and the pages the engine provides so you need not. None of them is a file you maintain — each is derived from the same content as the pages, on request, from the live layer only (one address, an entity’s own .json, is not derived at all: it is the content file itself, served as it lies). And none of them moves: every address is a convention, the web’s or CTXR’s, so a crawler, an assistant or another CTXR site knows where to look. This page is the one list; the pages that explain a single address link back here.
The bare forms — /data, /sitemap, /llms, /feed, /robots — redirect to the primary form (/sitemap → /sitemap.xml), per language too; a slug on any of them is refused by the audit. Where a site has more than one language, the addresses marked per language exist per language too (/en/sitemap.xml), from the same files; a single-language site has just the one.
Claimed by the web
Addresses the outside world looks for at exactly this place. The engine serves them so you never think about them.
| Address | What it is | For whom | Per language | What you may change |
|---|---|---|---|---|
/llms.txt |
the map: every page with title, description and address, your curated sections first — a page without a description stays out (the audit warns) | AI assistants | yes | the sections, from the project layer |
/robots.txt |
where the sitemap is, the site’s stance on machine use, pointers to the MCP and the map | crawlers | — | a real robots.txt in the web root wins |
/sitemap.xml |
the crawler index, with alternate-language links | search engines | yes | nothing — it lists what exists |
/sitemap.json · /sitemap.md |
the same page register for code and for a mind: every page with its type, file, name and date — the shape of /data.json, pages only, no bodies (a table in the .md) |
agents, the edit client | yes | nothing — it lists what exists |
/sw.js |
the service worker: what a device keeps and how it refreshes; at the root because a worker only controls paths under its own | the browser | — | nothing — the worker is the engine’s program; a physical sw.js would shadow it, and the audit warns |
/favicon.ico |
a redirect to the site icon | old browsers | — | nothing — the icon itself is assets/images/favicon.svg and .png |
Claimed by CTXR
CTXR’s own views. The site announces them itself — in the page head, in robots.txt, in llms.txt — and an agent that knows CTXR expects them here. The content lives under one prefix, /data, as it lies on disk: one address per thing, and two forms per address — .json for code, .md for a mind. The extension picks the form; the site never negotiates on an Accept header. And the leaf is the source, the folder is the reading: an entity’s .json is the raw file, every language inside it; an index is the page’s language, with @ids.
| Address | What it is | For whom | Per language | What you may change |
|---|---|---|---|---|
/manifest.json |
the app’s identity for a device: name, icon, colours — the browser learns it from the page head | phones and laptops | — | the data it is made from: the organisation’s name and icon, SITE_THEME_COLORS |
/data.json |
the index: every live entity of every type, the full form — a Schema.org DataCatalog with one Dataset per type, its field shape and its members. ?q=<words> searches it: ranked hits with a snippet (type, identifier, name; @id and url where the entity is a page or an anchor) — only its members, so what the language lacks is never a hit — paged with limit and a cursor (a ReadAction “next page”), never full records. /data alone redirects here |
assistants, integrations | yes | nothing — what it says is the content |
/data.md |
the same index as a list: per type a table of identifier, name, address and one line — the form to read, not to parse. ?q= there too, the same hits as a table |
assistants | yes | nothing |
/data/<type>.json · .md |
one type’s index, in the same two forms, ?q= on either; /data/<type> redirects to .json |
assistants, integrations | yes | nothing |
/data/<type>/<x>.json |
the entity file — the source, exactly what the MCP’s fetch returns: all languages as maps, references as stubs, no @id |
code, integrations | no — one file carries every language | the entity, through your agent |
/data/<type>/<x>.md |
the entity’s reading: its fields in the page’s language as front matter, its body as prose | assistants | yes | nothing — it is the file, read |
/feed.xml |
new content as it goes live | readers, services that watch the site | yes | which types or lists feed it (SITE_FEED_SOURCES — a type takes every entity of it from the index, a list its members); announced as soon as one is named |
/mcp |
the MCP: where an agent with a key writes | agents | — | nothing; who may write is in .actors/ |
The /data prefix is claimed whole: a page cannot sit on /data or under it, and the audit refuses the slug. A ?q= search is the one address that works per request rather than from the cache, so it is braked per visitor address (120 a minute by default): past that, 429 with a Retry-After — page with the cursor, do not re-run the words. An entity’s own address never shows a draft — ?draft= does nothing on the file; to see a staged entity, fetch it through the MCP with layer: "draft".
Not at an address: the docs
The engine’s documentation — these pages — is not served by a site. In a site it is read through the MCP, with any key and no extra right, because it is the contract: search { in: "docs", query } finds the page about something (hits carry the section, the headline and a snippet, never a body), fetch "docs" lists every page, fetch "docs/<section>" one section, fetch "docs/<path>.md" reads one. It travels with the engine, so the page an agent reads is the page that ships with the version the site runs. The site’s own rules, guide/, are read the same way, behind guide.read. See Keys and the MCP.
Cornerstones
Pages the engine provides so a site is complete without them — and that a theme may take over with a file of the same name, and then owns completely. Only pages are cornerstones: the app’s files (/sw.js, /manifest.json) sit in the tables above, because getting one wrong breaks the install on every device and nobody should have to think about them.
| Address | What it is | For whom | Per language | Takes it over |
|---|---|---|---|---|
/admin (and /edit) |
the wall: no login, an explanation for agents, the Discover list of these addresses | people setting up an assistant | — | theme/wall.php |
/graph |
the site’s relations as one map, not indexed | people, assistants | yes | theme/graph.php |
/offline |
the page shown when a page is not on the device | the browser | — | theme/offline.php |
/install |
how to add the site to a home screen, per browser | visitors | — | theme/install.php |
Claimed before your pages
Every address here is taken before the route table and the page register: a page cannot sit on /admin, and the audit tells you if you try. The root is not on this list — it belongs to the designated home entity, and a page whose address is /home is an ordinary page beside it, shadowing nothing. The technical precedence — what wins when a redirect, a route and a claimed path collide — is resolved by the engine before any page.
Live only
Every address here reads the live layer. A draft never shows up in the sitemap, the feed or the index until it is published; the preview link shows it to you alone — and the sitemap and /graph, opened with that link, show the round too (the register and the graph read live ⊕ draft, the others do not). See Drafts and going live. Why nothing here is a copy: Projections, never copies. The order an assistant reads them in: Discovery. The app files: An app by default.