# jtakeit — the whole documentation Schema contract 3. Generated from the source; do not edit. --- # jtakeit A back office for small businesses, with the website it runs: a CMS the owner edits by tapping their own page, bookings, enquiries, payments, analytics and hosting, behind one panel. Nobody is expected to hand-write a site here: an agent writes the schema, the pages and the content, a repository versions them, and the platform runs the part a studio does not want to operate — the panel the business owner uses, the enquiries, bookings and orders, the billing, the backups, the domain. Of all of it, the diary is the part no agent writes in an evening: rates by the hour of the week, a stay by the night or a hire by the day, several of one class in one booking, a party seated at the smallest table that fits, seats and spots, add-ons with no time of their own, paid online or on the spot — ten kits with a trade's defaults, and `preflight` booking and cancelling end to end before anybody else does. **In a hurry:** [start here](guides/start.md) — the first site in twelve steps, the rule at each. The agent in your session writes the site. The platform gives your client an admin panel they can use, a preview to sign off on before they pay, somewhere for the enquiries, bookings and orders to go, a host to serve it from, and a way for you to get paid. **Hand over the client without handing over the code.** What the studio gets out of it, in one breath: reselling — a wholesale price per live site and nothing for a site before its launch, its own price to its client on top, and the difference kept whole; the choice of invoicing the client itself or billing them through the platform on its own Stripe, which is part of every site and never a percentage; a diary that takes paid bookings straight to the business's Stripe; a handover that walks the studio out of the loop with one link; and a dev session that frames the local dev server with the owner's real text before anything is pushed. [The panel, by hand](guides/the-panel.md) has each of these by screen and by person. > **This is `0.x`.** The contract may still change between versions, and > [the changelog](changelog.md) says what moved and what to do about it. ## The shape of it Three things are true, and everything else follows from them: **Git owns what is published; the database owns what is being edited.** A site's design, its schema and its published content all live in that site's own repository. Drafts live in ours. This is what makes a build hermetic, what lets you keep your code, and what makes "give me this client as they were in March" a checkout rather than a support request. **The repository decides what a site is; the admin only fills it in.** There is no "add a page" button and no "add a block" button, and their absence is deliberate. A form that could invent a block your template does not render is a form that produces a broken site in front of your client. What the admin can do is bounded by what your schema, `jtk/schema.json`, declares, and you write that file. **A new site is a row, not a deployment.** One service, one database, one edge worker, however many sites. Nothing is provisioned per client. ## Start here - **[Connecting a site](guides/connecting-a-site.md)** — the five things that have to be true, and how to check each one. - **[The schema format](reference/catalogue.md)** — what you declare in `jtk/schema.json`, with worked examples that CI judges on every commit; and [the files under `jtk/`](reference/jtk-files.md) that hold the content. - **[Translations, key by key](reference/translations.md)** — the translation file: which values it holds, their paths, its records and what is refused. - **[Field kinds](reference/field-kinds.md)** — every kind, and what `min` and `max` mean for each (they do not mean one thing). - **[Modules](reference/modules.md)** — bookings: what the schema points it at, what it reads from an entry, and what the owner is asked. - **[A site in several languages](guides/languages.md)** — one original, a translation beside it holding only the words, and what is left to translate. - **[Draft, version, live](guides/the-three-stages.md)** — what an edit is before it is a commit. - **[When something is wrong](guides/troubleshooting.md)** — by symptom, and by [error code](reference/errors.md). - **[Driving it from an agent](guides/mcp.md)** — the MCP server, and what it deliberately will not do. - **[The panel, by hand](guides/the-panel.md)** — everything the tools do not do, where it is done and by whom; and [who can do what](reference/who-can-do-what.md), generated from the code that enforces it. ## For agents [`llms.txt`](llms.txt) is the map. [`llms-full.txt`](llms-full.txt) is every page in one file, in reading order — about a hundred thousand tokens, so read single pages unless you need the whole. Both are resources of the MCP server too, and every link a resource carries is a `jtakeit:///` URI the server can open. Every refusal — from the schema judge, from a build, from the annotation lint — carries a `JTK_E_` code with a path and a line of what to do. Look it up in [the error reference](reference/errors.md) rather than interpreting the prose. --- # Start here: the first site, in twelve steps The card: each step's tool or command, the rule that bites there with its code, and the page that says why. Read the pages when a step is yours. 1. **The brief** — every question at once, before `create_site`; build on the yes: the stack (offer Astro), the currency, **paid online or on the spot** (ask, never assume), where enquiries go, the language, the design, the photographs, the icon. Bookings take their kind's kit whole; a shop, `jtk add shop`. → [the brief](the-brief.md), [kits](../reference/kits.md), [the shop](shop-on-the-site.md) 2. **Make the site** — `create_site` with the slug, the name, `locale`, `locales`, `bookings` (a kit's kind), `shop`, `blog`, `design`; with bookings or a shop the brief's `currency` (asked, never guessed). The kit's `jtk create` commits contract 3, the quick template in Brumy's design (brumy.ch) — [`design: custom`](the-brief.md#a-custom-design) is a stage; its words and people are placeholders — write the site in their language before they look. `next` says the first build; give a person `get_preview_link` now. With a terminal: `scaffold: false`, then `npx @jtakeit/astro create ` (the same options), the dev server, `open_dev_session` and its `run`; give the developer the localhost. Fill `BRIEF.md` from the first answer. → [connecting a site](connecting-a-site.md), [working on a site locally](working-locally.md) 3. **Declare the blocks** in `src/content/blocks.ts`; `npx @jtakeit/astro schema` writes `jtk/schema.json`, mints missing `id`s and `_key`s — `JTK_E_UNNAMED`. A service has `takes`; a price is `costs` **or** `rates`; two rows on a minute are two prices — `JTK_E_DIARY_NOT_READY`. A date, an hour, a link is the owner's even unshown: `no_tap_target`, `beside` its field — `JTK_W_OWNER_LOCKED`. Entry types: `form`, `ends_by` (`ended`), `JTK_W_DATE_HIDES`. → [the schema](../reference/catalogue.md), [modules](../reference/modules.md) 4. **Write the content** — a page `jtk/pages/.json`, `{id, path, name, seo, blocks}`; an entry `jtk/entries//.json`, its values under `fields`; the text on every page `jtk/shared.json`. A value is its kind's: minutes for a time, `{"minor": 4500}` for money, an id for a `ref` — `JTK_E_DOCUMENT_INVALID`. **Another language** is `..json` beside the original, `of` its id, only the words by `_key` — a price there is `JTK_E_TRANSLATION_SHARED`; what is booked is in every language; `get_site` says what is left to translate. → [the files under jtk/](../reference/jtk-files.md), [several languages](languages.md) 5. **The settings** — `jtk/modules/bookings.json` is `{"v": 1, "settings": {…}}`, each row with its `_key`. A business open past midnight writes the hours after it on the calendar day whose clock shows them. A service priced by the hour of the week covers every open hour, or the uncovered hour is not sold — `JTK_W_UNPRICED_HOURS`. → [bookings on the site](bookings-on-the-site.md) 6. **Judge before the push** — `validate_schema` with the schema, **the `jtk/` files**, translations too (`jtk schema --judge` from the tree), and `site_id`: the settings, the entries and the currency in one answer. Act on advice — a service as a post, hours typed twice — `JTK_W_MODULE_POST`, `JTK_W_MODULE_TWIN`. → [the contract](../reference/contract.md) 7. **Annotate** — every field a person taps carries `data-jtk-path`, read off the built HTML, never the component: `jtkit lint dist/` on your build — `JTK_E_UNANNOTATED_FIELD`. An enquiry form's controls are the block's `asks` — `JTK_E_FORM_FIELD_UNDECLARED`. → [connecting a site · annotations](connecting-a-site.md#2-annotations) 8. **Push, then** `commit_and_build` — nothing public. `get_site` says where the code lives (`code`). First push: a GitHub remote in the copy → ask once (that repository, with our App a person installs, and `attach_repo`; or jtakeit); none → `push_code`, run its command, and say so. `get_build` until it settles, else `get_build_log`. «That slug is taken» with no id is another account's site. → [draft, saved, published](the-three-stages.md), [where the code lives](connecting-a-site.md#4-where-the-code-lives) 9. **Read what was built, and look at it** — `get_built_page` is the HTML; with `shot: "phone"`, the page as a visitor's phone draws it, in frames. 10. **Preflight** — `preflight` with `try_booking` (a shop: `try_order`) before saying done: the form says what it sends in `data-sends`, and a field the platform does not take is dropped from a stranger's booking — `JTK_E_BOOKING_FIELD_UNKNOWN`. → [bookings on the site · the form](bookings-on-the-site.md#the-form-is-the-sites-not-the-kits) 11. **Hand over what is a person's** — the launch, the channel the enquiries go to, the domain, another agent: the panel does those, and `preflight` says whose step each is. You cannot read the client's customers. → [driving it from an agent](mcp.md), [your client's data](your-clients-data.md) 12. **Later** — pull first (`git pull`, or `pull_code` and `jtk pull`); commit; `push_code` or `import_branch`; `commit_and_build`. Content not imported — a git push, or a document where you and the person's unsaved work changed one field (`JTK_E_DRAFT_AHEAD`, named in `waited`) — waits in the branch until the next save or the editor's opening brings it in under the draft; after launch the words are the panel's, the shape and seed text the repository's. `get_site` says what the panel holds unsaved, and on a launched site a build is a candidate a person publishes. → [working on a site locally](working-locally.md) When a tool refuses, the code is the page: [every error code](../reference/errors.md). --- # The contract, one line each What the platform enforces, and its code, checked before `validate_schema`, after [the brief](../guides/the-brief.md); [every error code](errors.md). ## The files Contract 3: - `jtk/schema.json` is written from `src/content/blocks.ts` by `npx @jtakeit/astro schema`, minting missing `id`s and `_key`s; else yours — `JTK_E_SCHEMA_UNREADABLE`, `JTK_E_UNNAMED` - a page is `jtk/pages/.json` (`/` is `index.json`), `{id, path, name, seo, blocks}`; an entry `jtk/entries//.json`, `{id, collection, slug, rank, visible, seo, fields, blocks}`; the shared text `jtk/shared.json`; a module's settings `jtk/modules/.json`, `{v, settings}` — `JTK_E_DOCUMENT_INVALID` - a value is its kind's: minutes for `time_of_day`, `duration`, `{"minor": 4500}` for `money`, `{"src", "alt"}` for a picture, `src` a library key (`media_link`), an entry's `id` for a `ref`; empty is absent; past `min`/`max` is advice — `JTK_W_CONTENT_BOUNDS`; an undeclared one is kept, shown nowhere — `JTK_W_CONTENT_ORPHAN` - a translation is `..json` beside its original: `of` its id, `locale`, only the words, by `_key` — a shared value `JTK_E_TRANSLATION_SHARED`; `translated` records `{from, by, at}`, best left out, never invented — `JTK_E_TRANSLATION_RECORD`; words for a key the original lacks — `JTK_W_TRANSLATION_ORPHAN` - `jtk/site.json` is the platform's; the currency is `create_site`'s, or its `currency` while it has none, then a person's — `JTK_E_CURRENCY_SET` - contract 2, until `jtk upgrade contract-3`: `jtk/catalogue.json` — `JTK_E_CATALOGUE_UNREADABLE`, `JTK_E_CATALOGUE_EMPTY`; `jtk/content/`, an entry under its `prefix` — `JTK_E_ENTRY_NO_COLLECTION`, `JTK_E_CONTENT_FILE_INVALID` - shapes: [files under `jtk/`](jtk-files.md) ## The schema - `contract: 3`, `generator`, `locale` (the original's), `locales`, BCP 47; no blocks is empty; an unknown key refused — `JTK_E_CONTRACT_UNKNOWN`, `JTK_E_GENERATOR_INVALID`, `JTK_E_LOCALE_INVALID`, `JTK_E_SCHEMA_EMPTY`, `JTK_E_SCHEMA_KEY_UNKNOWN` - a block declares `type`, `v` (raised: `upcast`), a `label` and a field; a field `key`, `label`, `kind` — `JTK_E_BLOCK_VERSION`, `JTK_E_UPCAST_INVALID`, `JTK_E_BLOCK_EMPTY`, `JTK_E_LABEL_MISSING`, `JTK_E_KIND_UNKNOWN`, `JTK_E_TEXT_INVALID` - names are `snake_case`, unique among siblings; a `select` has `options: [{value, label}]`; sane `min`/`max`; a `list` has `of`; a `media` says what it holds — `JTK_E_NAME_INVALID`, `JTK_E_NAME_DUPLICATE`, `JTK_E_SELECT_NO_OPTIONS`, `JTK_E_BOUNDS_INVALID`, `JTK_E_LIST_INVALID`, `JTK_E_MEDIA_INVALID` - `localized` on text, a picture, a link, a list; `integer` on a number; `qualifiers` on money; `untranslated` is `base`/`hide` — `JTK_E_ATTRIBUTE_INVALID` - `shared` lists the shared text's block types; a field there may say a `role`, each once — `JTK_E_SHARED_INVALID` - `render: "live"`, kept — `JTK_W_NOT_LIVE` - a collecting block says what; `views` name real fields — `JTK_E_COLLECTS_UNKNOWN`, `JTK_E_VIEW_INVALID` - what the owner edits is `client_editable: true`, `data-jtk-path` where drawn, any kind — `JTK_E_UNANNOTATED_FIELD` (phone, date, choice: `JTK_W_UNANNOTATED_FIELD` for now); drawn, untappable — `JTK_W_DRAWN_UNTAPPABLE`; derived: `data-jtk-from`; unshown: `no_tap_target`, `beside` its field (`JTK_W_HIDDEN_UNEXPLAINED`), a link its button's (`JTK_W_LINK_NOT_BESIDE`); `titled_by` a label — `JTK_E_BESIDE_INVALID`, `JTK_E_TITLED_BY_INVALID`; owner-locked date, hour, price — `JTK_W_OWNER_LOCKED` - a collection's `type` is a declared block; `route` `{detail, listing, per_page}`/`"none"` + `shown_on`; `order` `"manual"`/`{by, desc}`; `ends_by` → `ended` (`JTK_W_DATE_HIDES`); a `ref` `{to: [collection], many}` — `JTK_E_COLLECTION_INVALID`, `JTK_E_ENTRY_TYPE_INVALID`, `JTK_E_ORDER_INVALID`, `JTK_E_ROUTE_INVALID`, `JTK_E_REF_INVALID` - an entry type's `form`: `sections`, `aside`, `widgets` — `JTK_E_PANEL_FORM_INVALID`, `JTK_W_PANEL_FORM_GUESSED` - `modules` turns one on, at the schema's collections — `JTK_E_MODULE_UNKNOWN`, `JTK_E_MODULE_ROLE_INVALID` - a product: one SKU a site, any case; picks name each option; 1–2,000 variants — `JTK_E_SKU_TAKEN`, `JTK_E_PICKS_INVALID`, `JTK_E_PRODUCT_INVALID` - a service has `takes` and, to be paid, `costs` — or `rates`: day · from · until · costs rows, not with `costs`, none overlapping (`JTK_E_DIARY_NOT_READY`); an unpriced open hour — `JTK_W_UNPRICED_HOURS`; rows may name units, a service its `per`; priced without `takes` is an add-on — `JTK_W_ADDON_ALONE`; a resource may carry `hours` within the business's (`JTK_W_SESSION_OUTSIDE_HOURS`), `does`, `seats` or `spots` - what a module books is in every language: no `untranslated: "hide"`, no `visible: false` in a translation - a fact lives once: hours in the settings, prices in services — `JTK_W_MODULE_TWIN`, `JTK_W_MODULE_POST` - bookings settings: `kind`, `locale` pick the words (`JTK_W_KIND_UNKNOWN`, `JTK_W_KIND_MISSING`, `JTK_W_LOCALE_FALLBACK`); `words` override keys, placeholders kept (`JTK_E_MODULE_FILE_INVALID`, `JTK_W_WORD_UNKNOWN`); `hand_out`, no day rates — `JTK_W_KIND_NO_DAYS`; old `kit_version` — `JTK_W_KIT_BEHIND`; no `zone`/`hours` — `JTK_W_DIARY_UNSET` - format: [schema](catalogue.md), [field kinds](field-kinds.md), [modules](modules.md) ## The build - one kind of build, for the site's address: no `noindex`, no `Disallow: /`, a sitemap of every page on `SITE_URL`, a canonical on that host — `JTK_E_NOINDEX`, `JTK_E_ROBOTS_DISALLOW`, `JTK_E_SITEMAP_EMPTY`, `JTK_E_CANONICAL_ELSEWHERE` - every content page is built, in every language; every shared field is drawn — `JTK_E_PAGE_NOT_BUILT`, `JTK_E_SHARED_NOT_RENDERED` - an enquiry form declares `collects`, renders the contract's fields only — `JTK_E_FORM_INCOMPLETE`, `JTK_E_FORM_UNDECLARED`, `JTK_E_FORM_FIELD_UNDECLARED` - a `data-jtk-path` names a declared place by key (`blocks[hero].title`, `entry::title`); the schema is committed — `JTK_E_ANNOTATION_UNKNOWN`, `JTK_E_CATALOGUE_MISSING`; optionals empty, full — `JTK_E_CONTENT_VARIANT` - code is judged once: a content-only save keeps its verdict; failed code never goes live — `JTK_E_CODE_UNCHECKED` - a build reaches GitHub, npm, yarn, the media host, Google Fonts only — `JTK_E_BUILD_REACH` - `dist/_meta.json`: `redirects`, `immutable` hashed dirs, `cache` lifetimes, no `drafts` — `JTK_E_META_INVALID`; a kept file keeps its bytes — `JTK_E_CACHED_FILE_CHANGED` ## The order 1. `create_site` (`currency` when priced, `design`); `open_dev_session` shows pages 2. `npx @jtakeit/astro schema`, then `validate_schema` — the whole tree: as text with `site_id` before a push, by site and ref after 3. `push_code`; no shell: `read_files`, `write_files`; GitHub: `attach_repo`, our App, by a person; all import 4. `commit_and_build` — nothing public; `trigger_build` only rebuilds — `JTK_E_OUT_OF_SYNC` 5. `get_build`, `get_build_log`, `get_built_page`; `get_preview_link` for a person 6. `preflight` — currency, shared text; `custom`: `JTK_W_TEMPLATE_DESIGN`, `JTK_W_DESIGN_AXES`, `JTK_W_DIRECTIONS_ALIKE`; `JTK_W_FIRST_SCREEN`, `JTK_W_ANCHOR_LANDING`, `JTK_W_SCREEN_FIT`, `JTK_W_RAGGED_GALLERY`, `JTK_W_BOOKING_LINK`; `try_booking`, `try_order`, `self_check` — `JTK_W_PAYMENT_UNCHECKED` 7. later: pull (`git pull`, `pull_code` + `jtk pull`); commit, `push_code` or `import_branch`, `commit_and_build` — unsaved work: `JTK_E_DRAFT_AHEAD`, the save lays it over ## The boundaries - no tool writes content or structure but by a commit, imported, published - no agent reads enquiries, bookings, orders, members - a launch, a domain, an invitation, another agent — a person's, in the panel — `JTK_E_NO_BUSINESS`, `JTK_E_NO_DESTINATION`, `JTK_E_PLAN_SHORT` - on a launched site an agent's build is a candidate a person publishes, or rolls back, holds — `JTK_E_PUBLISH_HELD` - ten demo sites, 30 builds a day an account by default --- # Connecting a site Five things have to be true before a repository is a site the platform can serve. Each is checkable, and the point of this page is that none of them requires asking anybody. 1. The repository has a **schema**, `jtk/schema.json`, that validates, and its content files under `jtk/` in the shapes the schema gives them. 2. Every content field the page renders carries a **`data-jtk-path`**. 3. The build produces a **`dist/`** the way `pipeline.sh` expects (§3). The platform ships one scaffold, `npx @jtakeit/astro create`, and it is Astro: `create_site` runs it on the platform and commits its tree as the site's first commit, so a site made there is all five from the start; with `scaffold: false` the site is the row alone and you run it yourself. On any other generator you lay the site out yourself, to the same contract, and the build does not care which. 4. The site has **its code** somewhere the platform reaches: on jtakeit itself (`push_code`, or `write_files` from a chat with no terminal), or in a GitHub repository our App is installed on (`attach_repo`). The site row names it (§4). 5. Somewhere for **enquiries** to go, if any block collects them. ## 1. The schema The schema, `jtk/schema.json`, is the one file you write by hand — or rather, the one file your generator writes and you read. It declares the blocks your site is made of, its collections, its modules and its languages, and through them what the admin will let your client edit. The platform's own scaffold, [`@jtakeit/astro`](https://github.com/jtakeit/jtakeit-kit), derives it from `src/content/blocks.ts` with `npx @jtakeit/astro schema`, gives every page and entry its `id` and every block, row and picture its `_key` where a file has none, and checks the schema against the built pages both ways; start there. On another generator the file is yours to write, by hand or by a tool of your own (`npx @jtakeit/kit schema --declaration ` is the scaffold's), and the judge below reads it the same way — it is JSON, and nothing about it says what rendered the pages. The content sits beside it, one file per document, each in its own place: `jtk/pages/.json` for a page, `jtk/entries//.json` for an entry, `jtk/shared.json` for the text on every page, `jtk/modules/.json` for a module's settings, and a translation `..json` beside each original ([a site in several languages](languages.md)). `jtk/site.json` is the platform's, written by its saves. The [format reference](../reference/catalogue.md) has the shape and worked examples, and [the files under `jtk/`](../reference/jtk-files.md) each file's. The short version is that a block declares fields, a field declares a [kind](../reference/field-kinds.md), and `client_editable` on each field is what decides whether the client may touch it at all. Judge it before you commit it — the schema and every `jtk/` file beside it, so the content is judged with it: ``` POST /v1/registry/validate { "catalogue": "", "files": [{ "path": "jtk/pages/index.json", "text": "…" }] } ``` `validate_schema` is the same judge from the MCP server, and with `site_id` it holds the tree to the site as its import will (a new currency in `jtk/site.json` is `JTK_E_CURRENCY_SET`). It answers with **every** finding at once, not the first — so an agent fixing a schema does it in one pass rather than one build per mistake: ```json { "ok": false, "contract": 3, "findings": [ { "code": "JTK_E_KIND_UNKNOWN", "path": "blocks.hero.title.kind", "says": "blocks.hero.title has kind \"colour\", which nothing knows how to draw or check" } ] } ``` `path` is a dotted address into the file. `code` is one of [these](../reference/errors.md), and the reference says what to do about each. ### The contract number The schema carries `"contract": 3`. It answers one binary question — can this service read this file — and it is not a semver: a service meeting a *newer* one refuses loudly rather than half-reading it, and a refusal in that direction is a deploy to do, not a repository to fix. An older site may still be on **contract 2**: its schema is `jtk/catalogue.json` (written by `npx @jtakeit/astro catalogue`), its content a document per page and per language under `jtk/content/`, its bookings' settings `jtk/bookings.json`. The platform keeps reading and writing such a site as it is, and never rewrites a format on its own. `jtk upgrade contract-3` moves it in one commit, and the import that reads `jtk/schema.json` switches the site; the platform's team moves every live site itself. A tree with both files is refused, and so is a contract-2 tree pushed to a site already on contract 3. ## 2. Annotations Every value a page renders that a client may edit must be on an element carrying its path. On the scaffold the kit's door writes it — a template never writes a path: ```astro --- const hero = site.page('/', locale).block('hero'); ---

{hero.text('title')}

``` This is how the visual editor knows what was tapped. **It fails silently when it is missing** — the sheet simply stops opening on that heading, and nobody finds out for a week — which is why it is a gate rather than a convention. The annotation lint compares your built HTML against your schema in both directions and fails the build on a mismatch ([`JTK_E_UNANNOTATED_FIELD`](../reference/errors.md#jtk_e_unannotated_field)). It reads the **built HTML**, never your component source. That is deliberate: it then works with any template, including one an agent wrote this afternoon. A path names its place **by key**, never by position — a block, a row and a picture by its `_key`, a document by its `id` — so moving a block changes no path: | | | | --- | --- | | `blocks[hero].title` | a field of the block whose `_key` is `hero`, on this page | | `blocks[faq].items[r7k2].answer` | a field of a row of a list, by the row's `_key` | | `blocks[work].pictures[g2x9].src` | a picture of a gallery. The words beside it are edited in the panel and carry no annotation | | `title` | an entry's own value, on the entry's own page (its `fields`) | | `shared:blocks[contacts].phone` | the text that is on every page — see `jtk/shared.json` | | `entry::title`, `page::blocks[hero].title` | a value belonging to *another* document, as a listing tile does | The path is the same in every language: a document's identity spans its languages, and the page's language says which words the owner is editing. On a contract-2 site the same places are named by index — `blocks[3].title`, `shared:blocks[0].note`, `page:/blog/healing:blocks[0].title` — and the door writes that grammar there, so a template reads the same under both. Every value the owner edits is annotated where it is drawn, whatever its kind: a phone, an email, a choice drawn as its label, a date or an hour drawn formatted — the owner taps whatever they see. Two values drawn as one, «8000 Zürich», are two elements, each with its path. A list is tapped by its rows, a switch by what it switches, and a field with `client_editable` not `true` asks for nothing. For now a phone, an email, a link, a choice, a date, an hour or a number drawn without its path is advice ([`JTK_W_UNANNOTATED_FIELD`](../reference/errors.md#jtk_w_unannotated_field)); a contract-3 build will refuse it as it refuses a heading. A value the owner edits that the page draws as text where nothing answers a tap — under `data-jtk-fixed`, or under no annotation at all — is said too ([`JTK_W_DRAWN_UNTAPPABLE`](../reference/errors.md#jtk_w_drawn_untappable)). What a page works out rather than draws — «Jetzt geöffnet» from the hours, a week of opening hours run together, a postcode and a city that cannot be drawn apart — names its source with `data-jtk-from`, a path's document and block without a value: `blocks[]`, `shared:blocks[]`, `page:` and `entry:` (each may go on `:blocks[]`), `module:`. The kit's door writes it (`shared.from()`, `facts.from()`). A tap anywhere in that element opens the source in the panel, read-only, with what the site works out from it; a source that is not there fails the build ([`JTK_E_ANNOTATION_UNKNOWN`](../reference/errors.md#jtk_e_annotation_unknown)). The design's own words keep `data-jtk-fixed`: a tap on one says it is the site's design, and inside a region that names its source it opens the source. A link among them is offered in the panel, not followed. A value the owner edits and the page does not show — the hour a countdown counts to, a photograph's description — is `no_tap_target: true`, and says where it belongs with `beside`: the key of the field the owner taps, in the same block or row. The panel opens it under that field, as it opens a button's address under its words — so a button's link says `beside` its words (`"beside": "cta_label"`); without it the panel guesses by the names ([`JTK_W_LINK_NOT_BESIDE`](../reference/errors.md#jtk_w_link_not_beside)). One with nothing to go beside is under **More**, at the foot of the editor of every field of its block; give it a `hint` that says what it does, since the owner cannot see it ([`JTK_W_HIDDEN_UNEXPLAINED`](../reference/errors.md#jtk_w_hidden_unexplained)). A value whose title on the page is the owner's too — «Вход» over «18+», which may become «Цена» over «30 CHF» — says so with `titled_by: '