Skip to content

The panel, by hand ​

Everything the tools do not do, and where it is done instead. An agent that is asked how do I launch this, bill this, hand this over should answer with a screen and a person, not with I can't — and this page is that answer, one section per thing.

Two people use the panel, and they see different screens at the same address:

  • the studio — whoever's account the site belongs to; the people who build and sell it. The studio's own screens are Sites, Agents, People, Reselling, Referrals and Account.
  • the owner — the business the site is for; a client of the studio, with a role on that one site (owner, admin or editor). Their screens are the site's: Overview, Pages, Media library, Numbers, Enquiries, Diary, The site, Subscription, Payments, People — and Shop (Products, Orders, Stock, Shipping) on a site that sells.

Which role may do which thing is one generated table: who can do what. The rule it comes from is one sentence — an editor touches the content and sees the numbers; an owner or an admin touches the money, the domain and the people; the studio does what "not a builder" means: structure, address, repository, launch.

A studio member who wants to see a site as its owner does presses View as client on the site's screen. The same screens draw with everything only the studio can do taken out, which is how a studio finds out what the owner will be asked before the owner is.


The preview, drawn live ​

On a site whose template says it is ready — render: "live" in jtk/schema.json, which a site laid out by npx @jtakeit/astro create says from its first commit — the preview in the panel shows the draft as it is written into the draft, before a version is saved: a field the owner types is in the frame, drawn by the site's own code, within about a second of being written, and so is what the overlay cannot draw — an entry just added, a new order, a post in its listing, a post's whole text. Everywhere else the preview shows the last build with the draft's words laid over it: a write into the draft builds nothing, and an entry added appears in the frame once Save a version has made a version and its build is done, ten to twenty seconds later.

  • Who sees it. The site's own people editing it in the panel, and the same people opening Preview in a tab, which shows the draft as a visitor will see it (below), and the link an agent gives the person it works for (get_preview_link): it shows the draft as a visitor will, follows it as the agent writes, and says Draft, live or Latest version on its badge in the page's language. Until the agent has written anything of its own it shows a screen saying so instead of the kit's example. A preview link a studio hands a client, the version, the candidate, the showcase and the site's own address all show the build.
  • What is checked. The platform does not take the word for it: every preview build makes the site once more for a server and draws a few of its pages with it; where one differs from the built page beyond the names of the files it links and the size of its pictures, the build's log says which page and where (live: not drawn live — …), and the preview shows the build until the code changes. Nothing fails because of it.
  • When it is the build anyway. The first page after a while is the build: the site's renderer starts on it and draws the next. A renderer that is slow, busy or wrong is the build too. The frame says nothing about which it was; a tab opened with Preview waits longer for the draft, and where it is shown the version instead its badge says so — Preview · Version, the draft could not be drawn just now — and a reload asks again.
  • Pictures uploaded since the last build are shown as uploaded, at full size and at their own proportions (the library tells the renderer each one's width and height); the build optimises them.
  • What is published is always the build. Drawn live is only how the panel shows the draft; Publish puts the build of the saved version live, as before.

Preview is one control wherever the panel offers a page as a visitor sees it — the site's head, a page's screen, the editor: the button opens the draft in a new tab, as a visitor will get it, with every change in it, saved or not, and says Draft on itself; its chevron offers the version (the last save, as built) and, once the site is published, the live site at its own address. On the site's head the same menu keeps Open the editor and Open as the client below them. On a site whose draft is not drawn — the older contract, or a template that does not say render: "live" — the button is the version and says Version. The tab's badge names what it shows: Preview · Draft, Preview · Version or Preview · Live. For somebody who may edit the site — its studio, a studio it is shared with, its own people — the badge carries Edit in the panel beside it, in the page's language where the panel has it: it opens the editor on the same page, and the first time on a site a line beside it says texts and photographs are changed there. The link get_preview_link gives an agent is for the person it works for, and carries the button too, with a line that says to sign in first: the panel asks whoever opened it for a real sign-in and comes back to that page in the editor; the link itself still only shows the site. Any other preview link — the ones a studio makes in the panel for its client — an agent and a studio looking at the showcase see the badge alone, and the panel's own frame shows neither.

  • Preview over an entry's card. On a site drawn live, Preview on an entry's card opens the entry where it is seen — its own page, or the page that lists it, with a chip for each where there are several — scrolled to it and outlined, read-only, over the card, which keeps everything on it. What the card holds and has not put into the draft yet is drawn there too, for the person looking and nobody else: it is a short-lived preview layer over the draft, which a version, a build, another member and a visitor never see. It says when it was shown the last build instead, and on a site not drawn live, or for an entry shown nowhere, the button says why it is off.

The site's renderer runs the site's code in a container of its own, one site to an instance, with no network but the platform's draft of that site and its build cache, and no key of ours; it is stopped after ten minutes nobody asks for a page. How a template is made ready: docs/live.md of @jtakeit/astro.

On a page, a change goes into the draft as it is made: the frame is the preview. On an entry's card it goes in with Done. What is typed on the card — its fields, each language's lines under them, a language held back, the post's writing, the search fields — is held on the card, and a bar at the foot says 3 changes · Cancel · Done, a dot beside each field held. Done puts all of it into the draft in one step: one change in N unsaved changes under the header and in Compare, taken back by the toast's Undo for a few seconds and by Compare after. It writes everything or nothing: a value its field refuses, or one somebody changed meanwhile — another person's card, a tap in the editor, an agent's import — is marked on its field, and nothing is written. A field changed meanwhile says by whom and when, with Keep mine and Take this. Cancel forgets what is held. Leaving with something held asks Apply · Discard · Stay; closing the tab asks the browser's question, and the card offers what it held back the next time it is opened in that browser (Bring back · Discard), for a week. Cmd/Ctrl+Enter is Done; Escape never discards. Save a version and Publish in the bar under the header, pressed while a card holds changes, ask first: Apply and save, Save without them, or Cancel. Showing or hiding the entry, its dates and its address still act at once, as before. A post's writing held for ten minutes says since when it has not been in the draft. Preview — in the card's head with nothing held, in its bar while something is — opens the preview over it (above) where the site is drawn live: the draft, with Open in the editor beside it, or the draft with what the card holds and Done (Add for a new entry) beside it, which applies it from there. Elsewhere, with nothing held, it opens the editor on the entry's page, in the language the card is read in; with something held it is off and says why: the changes are in the draft after Done, and a new entry is there once a version is saved and built.

Where the entry stands is one line under the card's head, told apart by the three stages — the draft, a saved version, the published site — from what the site visitors are served has and what this entry's changes a save or a publish has not carried yet: In the draft (no version holds it shown yet: save a version, then publish); Saved in a version (it goes on the site with the publish); On the site, saying beside it when its latest changes are still in the draft or saved and not published; Appears on … (a date to appear, and whether a save or a publish still has to carry it); Still on the site (hidden in the draft only, where the switch could not act on the site — it leaves with the publish); Taken off the site or Not on the site (switched off, on a site that carries it or not yet); Taken off on … (its date to go has passed) — with the date it goes, where one is set. On a site never published — still being set up — nothing is on a site: what the preview serves is the version, not a site visitors have, so the line says Saved in a version or In the draft, and that the site's first publish puts it on the site; a hidden entry is Not on the site, never taken off one, and one past its end date is left out of the first publish. Beside Preview is one control for it: the act the state calls for — Show it on the site, Take it off the site, Change when it appears, or Show it again past its end — joined to a menu of what else makes sense in that state, each item with a line saying what it does: a shown entry is offered a date to go, never a date to appear; a hidden one a date to appear (setting it shows the entry), never a date to go; a date already set is offered as changed or taken away, not set a second time; an entry waiting for its date can be shown without waiting or kept off the site. Delete is the last item of that menu; its question says that the entry leaves the draft now and the site with the next version published, which languages go with it, what points at it, and that the list can bring it back until the next save. The address under the title follows the same stages: the live link while visitors find the entry there — on a published site only, never on one being set up; saved in a version and not yet on the site, the address it will be at as text, with See it in the version beside it, which opens that version's preview — never the live address; only in the draft, the address it will be at, as text; off the site, the address it is not shown at, as text.

On a site in several languages the card's languages are one panel: the language it is read in, and On the site in each language — a row for the original, shown wherever the entry is shown, and one for each other language with a switch and a sentence saying what it does: visitors reading the site in that language see this entry, or it is left out of that language's site. The switch is held with the rest of the card until Done. An entry the bookings book has no such rows: it is in every language, always.

How the card lays its fields out is the schema's to say, on a contract-3 site: an entry type's form (the schema) puts its fields in sections with a heading and a line under each, in rows of up to three on a laptop, with a column beside them for what the entry is at a glance — its photograph, its category — and chooses each field's control from its kind's few: a row of buttons for three categories, quick lengths for a duration, a stepper for seats. A phone shows every row as one column, the aside after the sections, in the same order the keyboard goes. A field's other languages hang under it as in the editor: each a row with its code, its state and the same box, open while there are fewer than three, folded from three; the language the card is read in only says which row is on top. A photograph keeps its words and their languages under More. A new entry is the same card, held from the first keystroke: what is written in it — a photograph, a price, an English line — goes into the draft with Add, as one change, and the screen is its card. What it still needs is said beside Add, which puts the caret there. Cancel, or leaving with Discard, makes nothing; a photograph already uploaded stays in the media library. Without a form, the card puts the title first (a post's date beside it), the pictures aside and short values two to a row; a field a form leaves out is shown under More, never hidden — but for the fields a module's own card draws, which no form lays out: the shop's product card draws a product's options, variants and Advanced itself (the shop), so a form lays out the rest of a product, its title, description and pictures, and needs no row for the card's. A form that places one is advised (JTK_W_PANEL_FORM_GUESSED), and the panel leaves the field out of it all the same.

Launching a site, and its domain ​

Who: the studio (owner or admin of its account) — and, on a client's site, the client themselves once they have taken it on the terms the studio set. Where: the site's screen, the last row of Setting up.

What has to be true first, and each one refuses in its own words:

  • somebody is responsible for the site — the client took it through the owner's link, or the studio took it as its own (nobody is this site's business yet);
  • the site holds a line of the plan — launching a site needs one site in this studio's plan is the plan being short, see reselling;
  • the site has a build repository;
  • if the site collects enquiries, takes bookings or takes orders, a verified destination exists for each, or nothing is set up to receive… — see where enquiries, bookings and orders go.

Launching revokes every preview link and serves the chosen build on a public address. Every site gets a handle of ours (<slug>-<suffix>.jtakeit.site) that keeps working for ever. The client's own domain is optional, attached at launch or later under The site → Domain: type it without https:// and without www, then set the DNS records the screen prints where the domain was bought. The screen says waiting until the records answer, which is up to half an hour. Until then the handle keeps serving the site as before — the domain usually still points at the old hosting while the records travel — and the moment Cloudflare serves www.<domain> with its certificate, the handle redirects there and the panel frames the domain. A domain of the client's is put into a Turnstile widget by the platform the moment it is attached. Nothing in the repository changes for a domain: no rebuild, no setting, no file.

preflight reports all of this after the fact; the launch button is the studio's and, once the terms are accepted, the owner's. The domain is the business's name: the site's owner or admin attaches it, the studio does so only on its own site, and on a client's site it reads the DNS status to help.

Going back to an earlier build ​

Who: a person with the publish right — never an agent on a launched site. Where: The site → Builds, Serve this build again on any finished build.

A rollback puts the older build in front of visitors at once and holds the site there. While the hold stands nothing of another commit goes live: a build that lands — a save, a rebuild, an agent's commit_and_build — waits as Built, not published, the publish buttons give way to a line saying why, and a publish asked of the API is refused with JTK_E_PUBLISH_HELD. An entry's scheduled moment and an entry switched on or off still reach the site: they build the held version again, which undoes nothing. The rollback restored the files, not the repository: fix the source, press Lift the hold on the same card, then publish the version that carries the fix. Lifting publishes nothing by itself.

The editor ​

Who: whoever may write the site's words — the owner, an admin, an editor, the studio. Where: Pages, a page opened to edit.

The frame is a build of the site — the saved version's, or the live one — with the draft laid over it: the page's own words, the text on every page, and the words and pictures of the entries the page shows, so a service renamed on its card reads as renamed on the services page at once. What only a build can draw — a price or a length the site's code writes out, an entry added, deleted, moved or hidden — waits for the next version, and a line over the frame says how many entries and leads to the comparison. The first open says it in one sentence: what is changed is kept in the draft; Save a version, then Publish, and visitors see it. Save a version and See the changes are in the bar under the header, as on every screen of the site — the one way to save, on a phone as on a laptop. On a laptop the rail beside the frame has one head, as a field's does: the language the page is read in, one chip that opens every language with what each has left and what that means for the save, and undo and redo — with how many steps each holds — at the right, where a field keeps them; Drop the draft is behind its ⋯, and asks first. Under it, the screen the frame is (a laptop, a tablet, a phone) and Preview, the page the frame is on as a visitor sees it — the draft, with the version and the live site under its chevron (above); then the versions, a line each on one line from the draft to what is live, with when and Publish on the version once nothing is unsaved — no commit is named in the editor; the builds keep those. On a phone and a tablet the same are in the toolbar over the page and its sheet. Every publish asks first, the first one above all — it gives the site its public address and ends the preview links — on a phone as on a laptop. Its Pages list walks the site: its pages, and under each collection whose entries have pages of their own its list (where the site has one, at its address in the frame's language) and its entries — those only in the draft too, marked new — a few at a time, with a search where there are more.

The frame is a real device's screen, chosen over it: a laptop (1440 × 900), a tablet (820 × 1180, an iPad Air) or a phone (393 × 852, an iPhone 15). It is the device's whole screen in its own shape, scaled alike both ways to fit the room and never above life size, and the page scrolls inside it; on a phone the phone's page takes the screen.

The comparison (See the changes) is laid out the same way, and opens on one of those windows: what the move puts out — the draft on the draft's pair, the version on the site's — on the device chosen with the same switch, with what changed outlined and tinted in the colour of what happened: amber changed, green added, red removed, blue moved. Compare with the version (Compare with live on the site's pair) puts the older beside it on the left, and scrolling one scrolls both. The page in each answers the pointer — a hover, a tab, a slider, an accordion — and stays the page compared: a link to another page of the site takes both windows to that page, and to the place on it the link names (Write to us on any page goes to the form); a link to a place on the page takes both windows there; the site's own language switch switches the comparison's language; a link that leaves the site is not followed — where it leads is said over the window, with Open in a new tab; a form is not sent. A row taken out is outlined only on the left, one put in only on the right; the choice is remembered. Over them, which two are compared, each pair with how many changes it holds, the language both windows show — on a site in more than one, the editor's choice, kept while walking the pages — and the move it leads to — Save a version or Publish. The list of what changed is grouped by page, beside the windows or under them on a laptop, where it opens wide to be read down whole, and in a sheet on a phone; the page on screen is opened onto its changes under the block each is in — a heading per block with how many changed in it, the page's own (its name, its address, what search engines read) under the page's. Each change is a sentence with names in it — Added item “Title”, Item “Quality” moved from place 3 to place 1, Price of item “Haircut” — its old value struck on red, an arrow, the new one on green, as a picture is; where the page does not show it, it says what it is: a link's address, a hidden field, what search engines read. Its dot is in its colour; Go to the change takes the windows to it and pulses it — and brings the older window beside the newer for what only the older shows — and on the draft's pair a change can be undone from its row. An entry with no page of its own is shown on the page that lists it, its tile outlined; one the site shows on no page is said to be nowhere.

A text or a button tapped on the page is edited where it is. On a laptop the rail turns into that field — which page it is on, in which language (the page's own language menu, so the field is opened in another from there), its words with how long they may be inside the box, its other languages hung from it as one field — each its code, its state and its words — and undo and redo beside the way back — and the element stays outlined on the page; the way back at the rail's head, or Escape, returns the rail to the page's state, with what was typed kept at once — and so does a tap on the page beside every field, except where the words cannot be written, when the field stays open and says why. Tapping another field switches the rail to it. One picture opens in the rail too: the photograph and Change the photograph — the picture itself does the same — which opens the library, to choose a file the site has or Upload new (a file dropped on it too), which goes into the library and is chosen at once. One photograph is changed, never taken away: the block is drawn around it. Its words, with their Other languages, are under More. A list opens in the rail as well: its rows, a line each — what the row says, a handle to carry it by (the arrow keys move it), and a ⋯ with Move up, Move down, Duplicate and Remove row — and Add a row at the foot, as far as the list's min and max allow, saying so where they do not. A row opens one step deeper: its fields, each with its control, its verdict and its Other languages; one the same in every language (localized: false) says so; the row's values the page does not show are under More, and All rows goes back. Tapping a row's words on the page opens the list at that row. The Add under a list on the page opens the new row the same way, every field of it at once; it is written once it has words and the fields it needs, and is taken away again if it is left empty. Read in another language, the list opens the same way: each row's words are that language's, written into its translation, with the original's words under each field before anything is typed — a word not yet translated says so, and is not a fault of the row. The rows themselves — which, and in which order — are one for every language, and are moved, added, duplicated and removed from there all the same: in the original, which a line by the handles says once. A row added there is made in the original's language, every field of it, and says so; the other languages then have it to translate. A gallery read in another language keeps its pictures and their order the original's. Every change is written into the draft as typing is; a row added, moved, duplicated or removed is a step of undo of its own. A gallery opens over the page: its pictures in an even, numbered grid, carried into order — the one carried lifts and the others step aside, as a list's rows do (Alt and an arrow on a tile, or the arrows by the picture) — with Add photos always at its head and a «+» at the end of the grid: the library, several marked at once and added together, Upload new inside it, as far as the field's max, which it says; files dropped anywhere on the gallery are added at once, each a tile while it uploads. The picture selected has its panel beside the grid, the single photograph's own editor — the picture, Change the photograph, and its words with their languages under More — and Remove from the gallery at its foot, which the draft's undo takes back; on a phone the panel is a step of its own. Its head is the rail's — the title, how many of how many, Add photos, the draft's undo and redo, and close; Done or Escape closes it too. A post's body opens over the page too, as on a tablet, where every field opens beside what was tapped — a list there in a column beside the page, the same rows and the same row; on a phone the field comes up from the bottom of the screen. A button opens as a text does — its words, and under them where it leads, where the site made that the owner's — with Follow the link (or Press the button on a form) at the top, which does what a tap on the site would, inside the frame. Where it leads is chosen, not typed: A page of the site, found by its name in the site's list, and a section of that page from a list of the same kind — The top of the page first, then each element of the built page with an id and a heading, named by the heading, searched where there are many — or Another site, an address checked as it is typed (example.ch is written https://example.ch). Switching between the two writes nothing: each keeps what it last held while the field is open, the link says where it still leads, and only a page or a section picked, or an address typed, changes it. The value is the same url string either way. Give the sections a link may point at an id and a heading of their own, or the owner can only send visitors to the top of the page. There is no button to keep it: what is typed goes into the draft after a short pause, and the editor says so — trimmed at its ends: a space typed at the end is not a change, and nothing is written for it.

What a block keeps that the page does not show is offered with what it does (no_tap_target). A field that names the one it belongs to (beside) opens under that field — the hour under the date. A link that names nothing opens under its button where the block has one button it can belong to: the words field named alike (cta_href with cta_label, a row's href with its label), or else the one field whose key says it is a button's (cta, button); where two could be it, it is with the rest of the block. Name a link's button with beside rather than leave it to the names. Read in another language, the button's link is still under its words — one address in every language, written to the original, and said so.

Every tap, one way ​

On a page a change goes in as it is made; on an entry's card it goes in with Done (above). Whatever is tapped opens the same rail (the tablet's popover, the phone's sheet), in the same parts. A line above the field's name says where it lives: This page · Hero; Shared text · Contacts · on every page (on every page in that language, where each language is a page of its own); an entry shown here, Team · Maria Muster — with wherever it is shown where its collection is shown in more than one place; a module's settings, Diary · Working hours or Shop · Shipping. The field is written in place whenever this person may write it, to the document it lives in — the shared text, the entry's draft, an entry's price, length, hour and reference too — and under a fact the bookings read (costs, takes, rates, a master's hours) one line says Bookings read this from here, once published, and under one the shop reads of a product, a variant's price among them, The shop reads this from here, once published: the draft changes, undo takes it back, and the module reads it after Publish. Right under the field comes what belongs to it, before anything else: where a button leads, the fields beside it, and its own lines without a heading — the button an address is beside, a field named alike (image and image_alt, cta_label and cta_href), a row's other fields. Then Also in «…» is the rest of the same source, in the schema's order, a line each — its name, its value as a list says it, and not on the page where the page draws no element for it (no_tap_target, or nothing on this page). A line opens as a tap on it would: the page brings the value into view where it draws it. At the foot, Open «…» goes to the source's own screen: an entry's card, the diary's working hours, the shop's shipping. Shared text has no screen; it is under On every page in the Pages list, each block opening as its source. On a tablet the lines wait behind Also in «…» (N). Read in another language, an entry's words tapped on another page are that language's, written into the entry's own translation.

What cannot be written here opens the same way, read-only, with its reason and nothing to type into. Every field a tap opens is outlined alike, a read-only one too; what is no field of its own — a region, the design's words — is not:

  • a field the studio keeps, for a client — The studio edits this one, as on the entry's card;
  • a module's settings — the diary's week, the shop's shipping — with Open «Working hours» or Open «Shipping»;
  • what the site works out — «Open now», a postcode and a city drawn as one — The site works this out itself, from «…», with that source's lines under it (the site names it with data-jtk-from, the kit's from());
  • the site's design words (data-jtk-fixed) — This is the site's design: the same for everyone, changed by the studio.

The design's words inside a field are that field's: a day's name in the hours, annotated as their list, opens the hours' rows — a day, when it opens, when it closes, each row open in place. A tap on a link's or a button's own furniture — an arrow, the padding — opens the one field it holds, and a link whose address is a field (data-jtk-href) and whose words are none opens that address — on contract 3 another document's too, named by its id (data-jtk-href="entry:<id>:ticket_link"), as a tile names it. A link or a button among them is offered with Follow the link and is never followed by the tap itself. On a contract-3 site an entry's own page — a post, a master with a page of their own — is edited by tapping like any page, its header and footer too; the body opens the writing.

The history ​

Who: whoever may read the site — the owner, an admin, an editor, the studio; never a preview link. Where: Changes history in the site's menu, and on every entry's card, under its fields.

What was changed on the site and by whom, newest first, ninety days of it:

  • Edits, not keystrokes. One person's writes on one site with less than thirty minutes between them are one edit, whatever pages they are on. An import or a push is one edit, from the code, named by the first line of its commit's message — so write that line for the owner, who reads it here: spring prices, not wip. A saved version and a publish are lines between edits.
  • Folded to one line — Anna changed 3 things on Prices and Team — and opened into what it changed, per page or entry, by name and never by address, each field by the schema's label with what it was and what it is: a text word by word, a choice by its option's words, a reference by the entry's title, a price in the site's currency, a body by its words. A change made in a translation says its language.
  • An entry's own history is the same timeline narrowed to the entry and its translations.

It is read-only: nothing brings a version back. A changed field of an entry offers Copy the old value, which puts the old value into the field on the entry's card as if it were typed — on the site's history it opens the card with the value in place. It is held on the card as a word typed there is, goes into the draft with Done, and through the three stages like any edit. A page's words are edited on the page, and the history shows them without a copy. No tool reads the history; get_site says what the draft holds unsaved.

Reselling ​

Who: the studio's owner or admin. Where: Reselling — Usage for what the studio buys and what it covers, Stripe account for the studio's own, which only charging a client through us needs — and each site's Ownership for what that client pays. The screen explains itself until Got it; after that the explanation is the i beside its title.

A studio here is a reseller, and the panel says so. It buys a line on its plan for every live site, at a wholesale price that falls with the number of sites. It sells its client a subscription of its own — its price, its invoice — set per site under Ownership, zero included. It keeps the difference, all of it: we take a price per site and never a share of what a client pays. The two prices stand side by side where the client's is typed; we never subtract one from the other, because the studio's is tax included in its own currency and ours is before VAT.

The studio buys a plan: so many sites, so many diaries, so many shops, monthly or yearly. Nothing is charged before the launch — a site starts drawing on the plan the day it goes live and gives its lines back when it is archived. A site holds one base line always, a bookings line if its schema turns the diary on, and a commerce line if it turns the shop on; the buy form offers the shop's line once it is on sale, and never more diaries or shops than sites. Every publish of a live site asks for the lines its modules need, so a shop turned on after the launch is refused its publish without one, and a line bought for a shop that took no orders is taken by the next publish, which opens it again.

How the client is charged is the studio's choice. It may invoice them itself, which needs nothing from us; or bill them through us, on its own Stripe account, which is part of every site and costs nothing more — below. A client who would rather pay us directly is a handover, and the site leaves the studio's plan. Prices are before VAT; Stripe adds it at checkout by country.

Buying is one form and a Stripe Checkout; changing the plan afterwards is the same form and is charged as the difference. The card, the invoices and ending the plan are in Stripe's portal (Reselling → Manage plan). Monthly becomes yearly, and back, on the same screen.

What refuses when the plan is short: launching (needs one site in this studio's plan, and there is none), turning bookings on for one more site, setting the terms of one more client's site. The sentence names the kind; the remedy is one more of it under Reselling.

A promo code — typed when the studio was named, or under Reselling → Usage until the first payment — may give free site lines for a time, and a discount on the plan for its first months. The lines say free until their date on the table of what is held, and a launch on one says what follows it. They are the studio's like any other line: its own sites and its clients'.

A business with its own account takes a code the same way. The code a link carried is applied when it signs up and chooses its business; otherwise it is typed on the site's launch or on Subscription, until the first payment. Free site lines cover the site line only, and a diary or a shop on such a site is bought beside them. A business's Subscription screen is the site's price list until there is a plan: what the site costs, monthly or yearly, and the button to Stripe. Once there is a plan, it shows the plan and what one more site or a module adds to it.

Referrals ​

Who: the studio's owner or admin. Where: Referrals. A blogger's studio makes a code per video there and reads each one's funnel — clicks, sign-ups, studios that launched, studios that pay — without the studios named — and What you earned, by month and currency: a share of what each studio it brought pays us, for three years from that studio's first payment, payable thirty days after it was earned and paid each month by transfer. A programme is turned on by us, on application in our Discord; a studio without one sees only how to apply. An agent cannot make codes.

The diary ​

Who: the owner (or admin), and the studio for the schema half. Where: Diary, and Diary → Opening hours.

Two halves, and both have to be there before a visitor can book:

  1. The repository declares the module — modules.bookings in the schema binding two collections, the services (entries with takes, minutes, and costs to be payable) and the resources (the people or rooms; one entry is a solo business). This is the studio's, committed and imported. Bookings on the site has the shape.
  2. The owner publishes the hours. Under Diary → Opening hours: the time zone, the week's hours, days off, slot length, how far ahead, how a booking is confirmed (at once, or after the owner says yes), how long a paid slot is held, until when a customer may cancel. Save and publish — a draft offers nothing.

Until both are true the diary says what is missing, and so does preflight: this site's schema does not turn bookings on, nobody has said which timezone this business keeps, nobody has said when this business is open, nothing in the services collection says how long it takes, the resources collection has nothing published in it. Each names the half that is missing.

The owner books people in by hand, confirms, cancels, moves, marks who did not come, and exports the whole diary. A booking carries how many it is for when the site takes a party — a table, a class — and a class that is full says so by the count, 3 of 3 places taken, when one more is booked by hand. The customer gets a page of their own to cancel or move from, reminders a day and two hours before, and a calendar file — none of that is set up; it is what a booking is.

When the owner moves a confirmed booking and the customer is told, the move stands at once and the customer is asked whether it suits — That works, Another time, Cancel — by email and, where a chat is linked, in Telegram. The booking says what they answered: change agreed by the customer, or no answer from the customer yet; each new move asks again.

A request from the site still waiting for an answer is not moved in the panel: it is offered another time. Its row, its side sheet, its card and Waiting say Offer where a confirmed booking says Move, and the window is the move's — the same free times and the same check — with a line saying the request will not change until the customer accepts, the owner's reason (one line, 200 characters at most, shown to the customer), until when the customer may answer, and the letter word for word; Offer sends it, and the customer is always told. The customer may answer until the business's hold for a request (two days where it sets none), and never past the offered start; a time already begun is not offered. A second offer replaces the first, and the window says so. Accepted, the request is confirmed at the offered time — the place is checked again at that moment, and taken meanwhile the offer is over, the request stays as it was and the owner is told; declined, the request is withdrawn by the customer; not answered in time, it lapses. Whatever the owner does to the request meanwhile — a yes, a no, a move — takes the offer back, and Withdraw the offer on the side sheet and the card takes it back on its own, the customer told unless the owner switches that off.

A request with an offer open says Offered and until when wherever it is listed, the time offered on its card, and sits below the ones Waiting still needs an answer to; the list of all bookings narrows by Offer. Offer is drawn off, with why on it, where none may be made: the request is waiting for its online payment (it is moved once paid, or settled on the telephone), it is a visit of several bookings, or the customer left only a telephone (JTK_E_PROPOSAL_NO_CONTACT — ring them). A request the business wrote down itself is moved as before. Dragging a request from the site on the diary's grid opens the Offer window on the place it was let go at (on its own place, saying why, where that has already begun); one that may be offered nothing goes back, and a note says why. Moving a request directly, without an offer, stays where it was for an agent and the API (POST /v1/sites/:siteID/bookings/:bookingID/move), and the customer is told of the move as before.

The shop ​

Who: the owner and an administrator, and the studio for the stock. The studio sees the orders in shape — numbers, totals and states, never a buyer — until the owner opens a window on Orders (or while it runs the site for the client), and never the money; an editor edits the products and sees neither the stock nor the orders. Where: Shop in the menu, on a site whose schema turns the shop on: Products, Orders, Stock, Shipping. Payments stays where it is, under the business.

Two halves, as the diary has: the repository declares the module and the products (modules.shop in the schema, jtk/entries/<collection>/<slug>.json, the shop on the site, the module), and the owner runs the shop in the panel — what is below. The counts are in no file, and a buyer can pay only once the Stripe account under Payments is ready.

  • A product's card. The card draws the product's options, variants and Advanced itself; the schema's form lays out the rest — the title, the description, the pictures — and needs no row for the card's. Products lists each product. To whoever reads the stock — the owner and the studio — it shows each one's price (from the lowest) and its stock in two columns: what is left, sold out, no stock set where a count was never given, or made to order. Under the name it names what the owner is to put right — no price, and no weight where a method prices by weight — and not on sale. A product over by its own date and kept on show is over since that date, and sold no more, whatever its stock says. A simple product is its price, SKU, stock and on sale in the card, with the weight when a method prices by weight. The stock in the card is the ledger's, written at once and not with the draft, and the card says so; whoever may not read the stock sees a sentence that says so and no box. Everything else the card changes of the product is held with the card's other changes and goes in with Done, the variants and the options too — a row removed, a value set for the selected rows (take off sale among them), Add options — each list one change on the bar, made to the product as the draft holds it, and forgotten by Cancel; take off sale offered for a variant an order bought is a change for each variant, or one with the list where the list is held already; a list somebody changed meanwhile is said over the table, with Keep mine and Take this, and a list the save refused is said there too, and either way nothing is written. Add options (sizes, colours…) asks the options and their values and makes a variant of every combination — each with a SKU made for it and the product's price and weight (the product needs its price first); at most 2,000, and past that it says so and makes none. The variants are a table, drawn as it is scrolled and one card a row on a phone; each edit is one row's field, a price, a weight or on sale can be set for the selected rows at once, a value added adds its combinations and one removed removes its variants. Advanced, folded, holds what buyers are asked besides the variant (a choice, a yes or no, a short text), whether the stock is counted or the product is made to order, the shipping size, the tax code, the customs tariff number and where it is made. The tax code is Stripe's, picked from a short list named by what the thing is — ordinary goods first, which is what a product with none is taxed as, then printed books, children's books, newspapers, magazines, food and groceries not eaten on the premises, clothing and footwear, and children's clothing and footwear — or another code, typed in Stripe's shape (txcd_ and eight digits) and written only once it has that shape. It decides the VAT only where the business charges it, as Payments says.
  • A SKU is made for the product — from its slug for one added in the panel (T-SHIRT-FOX), with its values' keys for a variant made from options (T-SHIRT-FOX-M-RED), a number added where the site has it already — and a copy of a product gets new ones. The owner may change a SKU until an order names it. A SKU an order named stays its variant's: the save refuses a draft that changes it or gives it to another variant (JTK_E_SKU_ORDERED), and an agent's push is held to the same. The card draws it read-only; a variant bought under a SKU it no longer carries offers Put back with that SKU, and a SKU an order bought as another variant, typed on this one, is said beside its box to be changed. A variant an order bought offers take off sale where its row would be removed; one that leaves the draft all the same — by a push, or bought after it was removed — is no fault, and its SKUs, like a deleted product's, are never given to another variant. Add options on a product that has sold keeps its sold variant, with its SKU and its stock, as the first combination. The whole product may still be hidden or deleted; its SKUs are never given again.
  • The stock. Stock is one table of every SKU of the products, by product and variant, with what is on hand, what is held — kept by checkouts now — and what has sold in three columns. A count is corrected in its box, sent with the count it replaces: when a sale or another person's correction came first it is refused, the box shows the count now and keeps what was typed, and nothing is overwritten unseen. A count below zero is drawn as oversold by N, a product made to order says it is not counted, and what the ledger holds for a SKU no product shows is listed apart. It is the owner's, an administrator's and the studio's, and closed on the sample site every studio sees.
  • The shipping. Shipping is the zones (a name and their countries; a country is in one zone) and the methods of each: a flat price, or prices by weight for each size (a letter, a parcel, bulky goods), or a pick-up, and free above an amount — with whether it covers bulky goods. Each change goes into the draft and is published with the rest, as the opening hours are; buyers are offered what is published. What the save would refuse is said beside its field before it is pressed, and each method buyers are not offered because of it, or because it has no price yet, is named at the top. A site whose repository has no jtk/modules/shop.json is told the studio adds it (jtk add shop lays it with a zone and two methods to price): the screen does not make the file. Like the opening hours, it is closed on the sample site.
  • The orders. Orders opens on what is to fulfil, newest paid first, with Fulfilled, Cancelled and All beside it, a search by number, name or email, and each order's state, a refund beside it (refunded CHF 20, refunded in full) and a dispute marked. An order is listed from the moment it is paid; a checkout never paid is not an order. Test orders — placed from the preview, paid in Stripe's test mode — are behind the switch that holds the diary's tests. The order shows everything to pack: the lines with their variant's values and the answers to the customizations, the buyer's name, email and phone, the address or the pick-up, the method, the subtotal, shipping and total, and — to the owner and administrators — the payment's reference, to find it in Stripe's dashboard, and each refund with its amount, what went back in stock and whether it is done, waiting for Stripe or failed. On an order taken with VAT on, the VAT Stripe charged is under the total, one line for each rate (including VAT 8.1%: CHF 2.91): the total alone (including VAT: CHF 3.52) where Stripe's rates could not be read in time, No VAT was charged on this order. where none was, and not known where nothing of it was read. Where the buyer paid in a currency of their own, the order says what they paid (paid as EUR 41.20); its total, its refunds and the export stay in the site's currency. An order taken with VAT off says nothing of VAT, not even VAT 0; a refund is shown as its amount and is never split into its VAT.
  • Fulfilled is one button for the whole order, on an order to fulfil. It takes a tracking number and its carrier (Swiss Post, DHL, DPD, GLS, UPS, or another, with its link typed), both optional, and asks once more: the buyer gets an email now, in the site's language — on its way with the tracking link, or, for a pick-up, ready for pick-up with the business's address. Fulfilled is final; the tracking number may be corrected afterwards, and no second email goes. A part-refunded order can be fulfilled; a cancelled one cannot, and the owner and administrators are offered none while a refund of all that is left waits for Stripe.
  • Refund and Cancel the order are the owner's and an administrator's alone. A refund is an amount — all that is left unless less is typed — with how many of each line go back in stock (put back in stock: never more than the order sold, less what earlier refunds put back) and a reason Stripe shows beside it. Cancel the order, on an order still to fulfil, refunds all that is left, puts every item back and leaves the order Cancelled. The button is off while a refund is sent, and pressing it again in the same window is the same refund, never a second. A refund Stripe has not answered is shown as waiting and asked about every hour; one that failed is marked, and its amount is the order's again. A refund of all that is left on an order to fulfil cancels it; any other order keeps its state, with the refund beside it.
  • The orders as CSV are a button on Orders: one row an order, with the buyer, the lines, the totals, when it was fulfilled and its tracking number, and the VAT and its rates when the shop charges VAT. The live file is the business's, or the studio's through a window (your client's data).

An agent sets a shop up and does none of this: no tool reads an order, fulfils one or refunds one, and set_stock sets the starting stock of a SKU that has not sold. It lays the kit with jtk add shop, brings a catalogue in with jtk import products, writes a product's tax code in the entry, in Stripe's shape, and sets neither of Payments's two switches.

Payments for bookings and orders ​

Who: the site's owner or an administrator — and never the studio. Where: the site's Payments.

Letting customers pay: for an appointment when they book it, and for an order in a shop — every order is paid online. The money goes to the business's own Stripe account, which the owner opens from this screen — person or company, then Stripe's own questions inside our panel. It is one account for both. Nothing can be charged until Stripe says the account may (the account exists and the questions have not been answered yet, then being checked, then ready). The setup list asks for it as soon as the site takes money — a diary that charges when it books, or a shop — and a buyer who comes before it is ready has nowhere to pay: preflight says customers can pay until it is.

The studio does not see this screen's contents. Payments are the business's books, and the account holding the site is not the business. The studio's Payments says who has to set it up and, while the site has no owner yet, offers the owner's link that brings one in (People, where the setting up's door mints it on arrival). Refunds are the owner's too — a booking's, from the diary, and an order's, from the order's screen (Shop → Orders, the order's Refund); the studio's diary has no refund button, and neither has its order.

Unless the studio runs the site for the client. A site's screen asks who is responsible for the site before it can go live, and the answer is one of two arrangements. We build the site; the client's data is theirs: the studio says what the client pays it for the site — zero is an answer — and the owner's link goes to the client with those terms on it. That answer is given the moment the terms are set — the site's line is held from the studio's plan from then on, and the notifications and the rest of the setting up no longer wait on the client; only the first publish does, until they take the site. Once they do, the enquiries and the money are theirs — and on their People screen, under Maintainers, they decide what the studio may see or touch: the records in full, and the money (the payee's form, sent to the client's own email, and refunds from the diary; never payouts, which are in Stripe's own dashboard). A client who will never open the panel opens it once, through the link, and grants both. This is our own site: the studio's owner and admins are the business by their role. This is our studio's own site: the studio member pressing it becomes the owner, and the enquiries and the money are the studio's — never the arrangement for a client's site.

What has to be true first: the site says what country the business is in (The site → The business, which the screen links to), and Stripe operates there. A service is payable only if its entry names a price as an amount; a price written in words is for the page, not for a card. A shop's prices are always amounts: a variant's price is one.

Two switches, beside the account. On a site that sells, once the account can take money, a card under it holds two switches. They are the business's like the rest of this screen, each is off until it is turned on, and each says what it costs. Today both act on the shop's orders and on nothing else: a booking's payment is neither taxed by them nor shown in another currency, and a site whose schema does not turn the shop on is not shown them, and sees this screen as it always was. A change acts from the next checkout: an order keeps what applied when its buyer went to pay.

  • VAT. Stripe Tax calculates the VAT on each sale. Stripe charges 0.5% of every sale it calculates VAT on, billed to your own Stripe account. The prices include VAT, so a buyer pays the price shown, and each product's tax code (Advanced, on its card) decides its rate.

    VAT is turned on only once Stripe says the account is ready for it — its tax settings made, the head office known, a VAT registration active — which the screen asks Stripe every time it is drawn. Until then the switch is held off and says what is missing, and Set up VAT opens Stripe's own forms on the screen, for the head office and for where the business is registered: brought into view, with a Close, shut of themselves once Stripe says the account is ready, and saying so when Stripe could not load them; they are offered too when Stripe could not be asked. A registration that lapses later leaves the switch on, and the screen says Stripe charges no VAT until one is active; an order taken meanwhile says that no VAT was charged on it. Where Stripe says more than a registration is missing — the tax settings, the head office — the screen says Stripe cannot tax a sale yet, so orders may not be paid until it can, and offers to turn VAT off. A change of the Stripe account — the account taken off the site, or another put on in its place — turns VAT off, and it is turned on again once Stripe says the new account is ready.

    The price is the same for everyone. Stripe charges VAT where the goods go — the delivery's address, or the shop's own for a pick-up — and only where the business is registered. A buyer abroad from a shop registered at home is charged none, pays the price shown and may owe import VAT at the door; the shop keeps its price whole. An address Stripe cannot tax opens no payment: the checkout answers 422 address and the order is given up, its stock given back (the shop protocol).

  • The buyer's own currency. A visitor from abroad sees the price in their currency and pays 2–4% more for it, or pays in the site's currency, which the sentence names. Stripe's page may show that buyer the price in theirs; the order, its refunds and the export stay in the site's currency, and the order page says what the buyer paid in their own.

No agent sets either: no tool, no file and no commit reaches them. The site's pages are told what is on, whether the prices include VAT and whether a buyer may pay in their own currency, by the shop's answers (the shop protocol).

We take nothing from these payments. Stripe's own card fee is the business's, as the seller — and so, on a shop's orders with VAT on, is Stripe Tax's, which Stripe bills to the business's own account.

Where enquiries, bookings and orders go ​

Who: the owner or admin — and the studio only while it runs the site for the client, by its own declaration on the site's screen. Where: The site → Notifications; the enquiries themselves are under Enquiries, the bookings in the Diary and the orders under Shop → Orders.

Every enquiry, every booking and every paid order is kept in the panel regardless, each on a screen of its own. What this screen decides is who is told: Telegram (a personal chat or a group, through the bot's deep link) or email (a code is sent to the address and typed back — nothing is ever sent to an address nobody proved they hold). The panel itself is not a channel.

The setup list asks it as one question, in the words of what the site takes — do you want your enquiries and bookings sent to your email or Telegram as they come in?, a shop's orders named with them. Yes opens this screen, which asks where: Telegram or email, then that channel's one step; once a channel is connected the screen says where they are sent, with a way to remove each and to add another. No is a real answer — the panel only, also offered on this screen while nothing is connected — and it counts for the launch exactly as a channel does; the screen then says nobody is notified, on a shop as on a site with a form. Connect a channel and that answer lifts on its own; remove the last channel and the question is open again. A site that gains a kind after it chose the panel alone — it starts taking bookings, or selling — is asked again, and the same No answers it: the panel then hears every kind the site has.

Test submissions — what a studio sends itself from the preview or try the form — can have channels of their own, under Also send test submissions somewhere? at the bottom of the same screen. They never hear a real customer, and the launch does not wait on them.

A channel is an address; what flies to it is its setting. A new channel hears everything the site collects — on a shop, its paid orders too — and on a site that collects several kinds each channel has a switch for each: enquiries, bookings, orders. So the bookings can go to the receptionist's chat and the enquiries to the owner's, or everything everywhere, and a shop's orders go wherever Orders is on. On a site with one kind a channel has no switch — until it does not hear that kind (a channel linked for enquiries, on a shop), and then it has that one. Every kind the site collects, orders among them, must be heard by at least one verified channel before the site can launch — this site takes orders and nothing is set to receive them is that refusal; it is the gate preflight reports, and the setup list's Notifications row names the kind still heard nowhere.

Before a handover the destinations must be the owner's, not the studio's: the enquiries still go to an address somebody set up here is that refusal.

People, roles and letting a studio in ​

Who: the owner or admin of a site; the owner or admin of a studio. Where: the site's People; the studio's People.

A site's people are invited by link: one use, seven days, with a role in it — owner, admin or editor. A studio's people the same way, into the studio — admin or developer; becoming the studio's owner is a transfer, not an invitation. The links are shown once; only their hash is kept.

An owner who wants a studio to work on their site does not invite its people one by one: they let the studio in, by its id (which the studio finds on its own People screen), and take it back with one action. The studio then reaches the site as a guest with the role it was given.

No tool invites anybody or lets anybody in. Those are decisions about people.

Handing the site over to the client ​

Who: the studio's owner or admin starts it; the client finishes it. Where: the site's screen → Hand the site over to the client; the client's link at /take-over/<token>.

The client gets an account of their own, pays us directly at the direct price, and the site — its lines, its repository (mirrored, so nobody is left who changes how the page is built), its people — moves to them. The line it held on the studio's plan is freed. The studio stays on the site as a maintainer, live or not, with the owner's four switches — records, money, domain, publishing — off until the owner turns them, and until the owner takes it off from People. On a site still being built — the client pays jtakeit directly under whom does the client pay, the other answer to the terms — the client's account becomes the site's business and the client pays from the moment they accept.

The card mints a link, shown once, good for fourteen days. Before it will: no Stripe account of the studio's is attached for the site's bookings, and the client is not being billed by the studio through us. Each refusal is a sentence naming what to undo. The enquiry channels stay as they are: the client confirms each one and takes any off from People.

The client opens the link, reads whose site and at what price before signing in, signs in through any door, presses Take the site over (this makes their account), pays at a Stripe Checkout, and the site moves the moment the money lands — the page waits for it, and the platform tries hourly for a tab closed at the bank. A client whose account already holds a free line is not sent to the bank at all.

If the client wants the studio back afterwards, they let it in from People.

Billing the client through us ​

Who: the studio's owner or admin. Where: each site's Ownership → Bill the client through us; Reselling → Stripe account once, before the first amount above zero. This is the sell half of reselling.

The terms of a client's site: what the client pays the studio for it, set before the client exists and carried on the owner's link, which is where the client reads them before signing in. Zero is a price — the studio invoices the client in its own way, or not at all — and needs no Stripe account. Above zero, the owner pays the studio through us, on the studio's own Stripe account, with the studio's invoice: we create the subscription, send the invoices and reminders, and show both sides where it stands. It costs the studio nothing beyond the site itself — no line on the plan, and never a percentage of what the client pays. The site's line is held from the studio's plan the moment the terms are set, and given back only by the studio's own hand: withdrawing terms nobody took, or ending the billing — which, on a live site, takes the site off its address. The client's money goes to the studio's Stripe whole; what Stripe keeps is the studio's as the seller: the card fee, and Stripe Billing's fee on subscription volume.

First, once: the studio's own payment account under Reselling, by country (named, in the reader's language; a country not in the list is one Stripe does not serve, and Stripe is the only provider today) and person or company, then Stripe's questions. Then per site: what the client pays, in which currency, monthly or yearly, by card (the owner enters one once) or by invoice (Stripe emails it with a page to pay on, fourteen days), the client's email, and whether to freeze the site after fourteen days unpaid — off by default.

The owner's Subscription screen then says what they pay the studio and offers the two buttons that pay it, and Stripe's portal for cards and invoices. The price and the interval belong to the running subscription: to change them, stop and start again, so the owner sees a new first invoice and never a surprise on the next.

When a subscription is not paid ​

Two ladders, and each freezes only what is its own.

The studio stops paying us. Day 0 a letter; day 14 the freeze — editing, publishing and new enquiries, bookings and orders stop, the site stays up, reading and export still work; day 23 a final notice; day 30 the dark — the site answers 503 with a maintenance page. Paying brings the freeze off at once and the site back within the minute. The owner's Overview says so in plain words, and every refusal in the frozen state says this site is frozen: its subscription has not been paid.

The owner stops paying the studio through us. Only if the studio asked for it: an invoice fourteen days overdue freezes the site — never the dark. The refusal says the payment to the studio that runs it is overdue, the owner's Subscription screen has the button that pays it, and paying thaws on the next tick.

Neither ladder archives anything or deletes anything.

Giving a site to another studio ​

Who: an owner or an admin of the studio. Where: the row menu on Sites — Give to another studio, on a site nobody pays for yet: never launched, not handed to a client, no client terms on it.

It makes a link that works for seven days and is shown once. Whoever opens it in another studio they own or run takes the site whole: pages, versions, pictures, its address. Your studio loses it — its preview links stop working and the enquiries the demo collected are deleted. Your repository stays yours; the site builds from the platform's copy of its code until the other studio attaches a repository, and an empty one is given the code. A launched site does not move this way: its client decides who works on it, from People.

Between two studios you run, the same sheet moves the site at once, with everything — its enquiries, channels, guests and repository — and a launched site may go too: it takes a place in the other studio's plan, which must have one.

Switching a site off, archiving it, and the data ​

Who: the studio. Where: The site, and the row menu on Sites.

Switch off gives visitors a maintenance page instead of the site, keeps search rankings, and comes back in a moment; the reason is for the studio and never shown. Archive takes the site off the internet, revokes its links, gives its lines back to the plan, and keeps the content and the builds, so it can be undone. What happens to the enquiries, bookings and orders afterwards is your client's data.

Bring back — on the archived row's menu, and on the archived site's own screen — undoes it, as far as it goes: the site comes back as a draft, off the internet, with its pages and its last build behind the preview, and it takes one of the studio's places for sites that are not live again. It does not go live by itself. Launching it is the same Go live it was the first time, which asks the same questions — where the enquiries go, whether the plan has a site left — and puts the addresses it had back. While a site is archived nothing is built and nothing is served: Publish, a rebuild and Serve this build again are all refused until it is brought back.

What the site reaches ​

Who: the owner and the studio. Where: The site → Outside services, the last tab (it was a place in the menu until 13 November 2026; the old address leads to the tab).

The addresses the published site loads something from while somebody is on it — fonts, analytics, a map — read off the files it was built from, so the list changes with a publish. What could not be read (an address put together as the page runs) is said as such, never as nothing.

A collection's entries ​

A collection — the services, the masters, the works, the posts — is a list the owner adds to, and its screen is where they work through it. Who: the owner, an admin or an editor, and the studio. Where: the collection's own item in the menu.

  • Finding. A search box (the title in either language, the slug and the entry's text, without case or accents); Filters to narrow by whether the entry is on the site, by any choice or reference its type has, and by how far a language has got (to translate, outdated, translated, held back); Sort, a way to view the list that never changes the site — as on the site (the collection's own order: by hand, by a date or by a field; on a dated collection it says which way it runs and offers the other), by title, recently changed; and on a site in several languages, the language switch above the list, which says the list in that language and what is left to translate there. The list is answered by the server a page at a time, with Show more, and what was asked stays in the address, so coming back from an entry lands on the same list. Each row says its title, what is unusual about it (hidden, appearing later, going on a date), a few of its values, a mark per language, and who last edited it and when — an edit to the entry or a translation; saving a version or publishing is not one.
  • A new entry is on the site in the draft — a post from New post, a service or a master from its form, a copy of a shown entry, a row of an import: in its listing in the preview at once, and visitors see it after Save a version and Publish, like any change. The form of a record makes the entry with Add, every field and every language's line in at once, or makes nothing and says which field it refused. Save a version first names each entry the version would put on the site for the first time — new, or shown again — with Keep off the site beside it (its switch off, in the draft), and asks nothing when there is none; Publish names those its version would put up, and one kept off there is left for the next version, which the ask then offers to save. A save refused because an entry on the site is not finished names each one, with Open it and Keep it off the site for now, which switches it off and saves again; one visitors already see is only opened, to be finished. Nothing is ever switched off without being asked.
  • The order on the site. On a collection ordered by hand — services with the signature one first, the team with the owner first, questions, galleries, rates — Change the order on the site shows the list in the order visitors see it, and the booking form where the bookings read the collection; search, filters and sorting are off meanwhile, and Done brings them back. On a laptop a row is dragged by its handle, or the handle is focused and moved with the arrow keys; on a phone or a tablet each row has up and down. Each move goes into the draft at once, like any edit, and where the list is grouped an entry moves within its group. A collection the site orders by a date or a field has no such button: it orders itself.
  • Several at once. Tick entries and the bar at the foot of the screen shows, hides, sets a choice or a reference, or deletes them. It is one change, all or nothing, saved and published like any other; a deletion asks first what names the entries, and refuses those with bookings ahead.
  • Duplicate, in a row's menu: a copy with its translations, at a new address with copy in it in each language, right after the original where the collection is ordered by hand, shown or hidden as the original is. Nothing that named the original names the copy.
  • Where an old address goes. Deleting or hiding an entry that has a page of its own — from its row, the bar or its card — asks where a visitor who has its address is sent: the collection's list (the default), the home page, another entry, an address on the site, or nowhere. The platform redirects it once the deletion or the hiding is on the site: a deleted entry's address for good (301), a hidden one's for now (302), and showing the entry again takes it back. The site → Old addresses lists every address the site has left — moved, deleted or hidden — with where it goes; the owner changes the place or removes the redirect there.
  • Bring back. Under the list, the entries deleted in the draft — from the list or from an entry's card, which says so as it closes — each with its translations and who deleted it, and Bring back. It is refused, with nothing moved, where another entry has taken the address since. After a save a deletion is a commit, and the entry is in the site's history.

An agent does none of this through a tool: it reads a collection with list_entries, every entry with its values, and changes entries in the files and a commit. Redirects for addresses a site's files no longer have are the platform's; an agent writes none of its own for them.

Languages ​

A site has its own languages, declared in the schema (locales). The panel itself is read in the reader's language — their choice, in the menu under their name — and every label the schema carries has a word in each. A site's language and the panel's language are two different settings.

On a contract-2 site a page exists per language the repository says it does, and each is edited as a page of its own.

On a contract-3 site every page, entry and the text on every page is one document in the site's own language — the original — and each other language holds only its words (a translation, <name>.<locale>.json beside the original). The owner edits them as one. Who: the owner (an editor too), and the studio. Where:

  • A switch of languages in the editor's rail (on a phone in the toolbar over the page, with undo and the widths), on a page's own screen, on an entry's card and on a collection — in the rail, on the card and on the collection one chip with the language read now, which opens every language. The site's own language is named as the original; each other language carries a mark — nothing when it is complete, otherwise how many of its words are still to translate and how many are outdated (translated from an original that has changed since). In the editor the chip's menu lists them, on this page and its shared text, each named as it reads — Values · Calm · Title — and a tap opens that one in its language, outlined on the page; Next to translate, in the menu and under a field read in that language, walks them. On a collection, beside the chip, the screen says in words how many entries wait for a translation in each other language — DE-CH: 1 entry waits for translation, a press away — or that every entry is translated; choosing a language lists the entries with something left in it. The language chosen in the editor, on a page's screen or on an entry's card is remembered for the site while the tab is open, so the next page opens in it.
  • A page's own screen and an entry's card in a language show the page in that language — the picture at its address there, /en/… — and Search results holds that language's title and description, written into its translation with the card's button. A field the language leaves empty shows the original's words under it, marked as the original's; the share picture is the original's and changed there.
  • The preview in a language shows the page as that language does. A value still in the original's words is outlined in dots and counted in the rail, never passed off as translated. A text tapped there holds that language's words and is written into its translation.
  • A photograph, a gallery's pictures, a price, a date, a link are the same in every language: edited from any of them, they change all of them, and the editor says so.
  • Other languages, under every text being edited: a line per language with its words and where they stand — original, current, outdated, not translated, machine, unchecked — opened and edited in place, the original's line too. A line saves the way the field above it does: in the editor after the same short pause, said at its foot and taken back by the same undo; on an entry's card held with the field above it, and into the draft with the card's Done. There is no button to keep a line, and none to take it out: a line emptied and left is taken out, and the language shows the original's words again, not translated. A line offers Checked on a machine's words (read, kept as they are). One or two other languages are open at once, a field each; from three the block folds — on a phone to one line until tapped, in the rail by its heading, each line opened in place. A picture's description is per picture.
  • Editing the original — in its own field or on its line — says under it which languages still show the earlier text; nothing asks first.
  • An entry's card has Show every language — every text with a row per language, to translate a whole entry in one pass — and a switch per language to hold the entry back there. A master, a service or anything else the bookings book is in every language, always, and has no such switch: a missing translation shows the original's words. A post's writing is whole per language; the card says where it stands and copies the original's as a start.
  • Before a version is saved, the rail says what is behind — 12 texts are not yet in EN, 3 are outdated. It never stops the save.
  • The Languages screen, The site → Languages: each language's coverage, and what is left to translate grouped by page and collection, each a way to where it is edited in that language.

Every change in a language is a change to the draft like any other: counted, saved with the next version and published with it. What the panel writes is recorded as a person's (by: person) and what an agent writes in the files as the agent's; get_site says per language what is still to translate.

Machine translation ​

Where the platform has a DeepL key, a person in the panel can have the machine draft a language's words. Who: whoever may write those words — the owner, an editor, the studio. Never an agent: an agent is a translator in its own right and writes <name>.<locale>.json in the files; no tool sends anything to DeepL. Where:

  • Translate on a line of Other languages: that text, that language.
  • Translate all above the lines: every language where that text is not translated or outdated.
  • Translate all on an entry's card: the whole entry, every language.
  • Translate now · Later under an original whose words changed: what has changed in that page or entry so far, in every language.
  • Translate all (about 3,400 characters) on the rail before a version is saved, and Translate all per language on the Languages screen.

What the machine writes is a draft like a person's words, recorded as the machine's (by: machine) and marked machine, unchecked until somebody presses Checked. It reaches visitors only with a version and a publish. Only words are sent: never a price, a picture's file, a reference or a link's address, and markdown's and rich text's markup is kept as it was. A post's writing is translated whole.

How it speaks, on the Languages screen: formal or informal per language (formal unless somebody says otherwise — Sie, vous, Lei), and the words it never translates, one per line. The business's name is always kept, and the names of what the bookings book are kept as each language already says them.

What it costs: a paid site has 30,000 characters of machine translation a calendar month, not carried over; a demo 10,000 once. The Languages screen shows what is used. Text translated before costs nothing again. Past the allowance the buttons say why and are not pressed; translating by hand works as always.

Off is the default: with no key the panel shows none of this, and nothing else changes. A person sets the key (DEEPL_API_KEY on the host; staging uses DeepL API Free). Production stays off until the processing list and the data processing agreement name DeepL as a sub-processor; then the owner sets its key.

The business's facts ​

Who: the owner (an editor too), and the studio. Where: The site → The business.

Name, address, telephone, opening line, and — the two that other things wait on — the country and the currency. Payments, for bookings and for orders, need the country — and a shop's checkout needs it to say when a buyer abroad pays the duties at the door; prices need the currency; the diary needs its own time zone, which is set with the hours. The schema declares the facts the pages print; the country and the currency are the platform's and are on this screen whether or not the schema names them, as selects — a country in the reader's language, never a code typed by hand. An agent building a site from a brief knows all three on day one; the panel is where they are written down. The currency the agent may give once: create_site's currency, or currency in jtk/site.json while the site has none, which the import takes. Once the site has its currency it is changed here, by a person — the select asks first on a site with prices — and a contract-3 import that brings a new one is refused (JTK_E_CURRENCY_SET). A branch still saying the currency the last save wrote, from before a change here, is left alone, and the next save writes this one. preflight fails a site whose pages show prices while it has none, naming this screen.

On a contract-3 site this screen holds the country and the currency, each saved on its own; Payments sends the owner here for the country, and offers it itself. The business's name, address, telephone and the rest are the shared text's contacts (jtk/shared.json), each field with its role: the owner edits them on the page like any other words, through the three stages, and the site builds its structured data from them. preflight checks that every value filled in there is drawn on the pages.

The media library ​

Who: the owner (an editor too), and the studio. Where: Media library, beside the pages; and From the library under every picture and gallery field — Change the photograph on one tapped on the page. Wherever it opens to choose from, Upload new (or a file dropped on it) puts a new file into the library and chooses it at once.

Every picture and clip the site has uploaded, newest first, each with its size, when it came, and where it is used: every page, entry, the shared text and a module's settings that names it, at its place by key (blocks[hero].image, an entry's cover), in which stage — the draft, the version, live — and every translation that gives it words in its language. An agent reads it through media_link and npx @jtakeit/astro media pull '<url>' (the pictures, into the library), or, without a shell, through get_site's library — the newest files and whether a field names each yet; the same answer is GET /v1/sites/:siteID/media for a person's session, each file with its name, its width and height as drawn, its origin (person, agent) and its thumbs.

The photo page (/drop) is the library's door for somebody who is not signed in here: the agent's media_link hands it out, the person opens it on their phone, sees the site's name, and chooses or drops photographs; each shows its progress and its result. In a chat that renders MCP Apps, the same page is a box under the agent's answer instead. The link is good for an hour and for pictures only; what arrives is in this library with the agent as its origin, and the agent places it.

What the library keeps is not quite what was sent. Every upload, from the panel or any other door, is cleaned on the way in:

  • The metadata goes. A phone writes where a photograph was taken into it (EXIF GPS), and the camera and the time to the second. The library takes EXIF, XMP, IPTC and comments out of a JPEG, PNG or WebP without touching its pixels, keeps its colour profile, and keeps its orientation, so a portrait still stands up. A clip loses the place it was filmed the same way; an AVIF's metadata is blanked where it lies. An SVG is kept as it came, once it is safe to serve.
  • A JPEG or PNG longer than 2 400 pixels is scaled down to 2 400 on its long side, turned the right way up, in its own format. A WebP or an AVIF is kept at its size (the panel sends a smaller one already).
  • Thumbnails are written beside each JPEG, PNG and WebP: copies 160, 480 and 960 pixels wide (the ones narrower than the picture), JPEG — or PNG for a picture with transparency — at <key without its extension>.w<width>.<thumb_ext> on the same host, served the same way. The library says each file's thumbs and thumb_ext; the panel's lists draw those, not the original.

A file's key is the hash of what was kept, so the same photograph sent twice is still one file. In a dev session, Upload new puts the file into the library of the site the session copies — the one its content will name once it is committed.

  • From the library places a file the site already holds instead of uploading it again. A file uploaded twice was always one file (its key is its contents' hash); this is the way to find it again.
  • A file's words. On a contract-3 site a file has its own words, its alt, in the site's language. A picture placed without words of its own — from the library, or by an upload of a file the library already describes — takes the file's. A field's own words override them, and a translation's override both in its language (translations). Changing a file's words gives the new ones to every place still saying the old ones, as a change of the draft: counted, compared, saved and published like a word typed there. Places whose words differ are left. The words live in the content, so the build and get_content read them as any value.
  • Deleting asks first, with the picture, and is refused while anything uses the file — in the draft, the version or on the live site — and the screen says where. Put another in its place swaps another of the library's files into every place of the draft the person may change (a field the design keeps is left and counted), its words going with it where they were the old file's. Once that is saved and published, the old file can go. A deleted file stays in the bucket for older builds until the site is archived; uploading the same bytes brings it back, and so does saving content that names it — an older version copied back from the history, say.

A collection as a spreadsheet ​

Who: whoever may add entries (the owner, an editor, the studio). Where: a collection's screen, Export to CSV and Import from CSV, below the list. Import from CSV opens a dialog (a sheet on a phone): a place to drop the file or press to choose one, Download an example — the collection's own columns and two example rows, which import as two new entries — and Download the current entries to start from where the collection has any, the format in four lines with this section behind them, and — once a file is dropped — what it would do, in the same dialog, with Import N and Back.

The export is one row per entry, in the collection's order, written as every CSV here is (the CSV files: semicolons, UTF-8 with a byte-order mark, CRLF):

id;slug;visible;title;date;cover;cover.alt;pictures;price (CHF);section;category;tags;body;title@en;cover.alt@en
0193a5c3-…;eiche;yes;Eiche;2026-03-01;media/…/9e8d7c6b.jpg;Eichentür;media/…/a1b2.jpg | media/…/c3d4.jpg;120.00;Holz;Schönheit;Rot;Eiche.;Oak;Oak door
  • id, slug, visible (yes or no; left empty, a new entry is shown and an existing one keeps its switch), then each field of the entry's type by its kind: words as they are; a number as digits; money in major units, the column naming the site's currency (45.00, from 45.00, on request); a length in minutes; an hour as 09:30; a date as 2026-11-12; a switch as yes or no; a choice by its label; a reference by its entry's title where that title names one entry, else its slug, several joined by |; a picture by its file's key, its words in <field>.alt; a gallery's keys and a list as JSON, which are read and changed in the panel, not here.
  • One column per field with words, per language — title@en, cover.alt@fr-CH — the translation's own words; empty where it has none.
  • The cells are written as every export's are: a cell a spreadsheet would run as a formula starts with an apostrophe, which the import takes off again.

The import reads such a file twice. First it says, without writing anything, per row what would be added (and hidden, where its visible says no), changed or refused, and per cell what each change is (was → now) and why one is refused: an amount that is not one, a choice the field has not got, a reference to no entry or to two of one title, a currency that is not the site's, a picture the library does not hold, an address changed (that is the panel's, with its redirect), a gallery or a list changed, a field the design keeps and the person may not change. A row with one refused cell is left out whole. Then Import sends the same file with the plan it was read as: under the site's lock, the plan is made again and written only if the collection is still what was read — otherwise check it again. Each entry is one change of the draft, each language's words go into its translation, and new entries are made at the collection's end as the panel makes them. Nothing is published by it: the rail counts it as unsaved work.

A collection the bookings read is exported as its entries — the services, the masters — never what was booked of them; those are the client's records, and leave through their own exports. And what a module books is in every language, so the import never holds an entry back in one.

A shop's products are not brought in this way: what they sell is lists — the variants, the options, the customizations — which this import does not write, as it writes no list. A catalogue comes in as an agent brings it, with jtk import products (the shop on the site), and the panel is where the owner changes it after.