highport.space

Highport orbital control

The Station Manual

Let's be honest, nobody reads a manual for fun, and nobody wrote this one for fun either. Find the section with your problem in it and reach out if you're stuck.

Visitors

For when you're on a site somebody has launched with Highport.

  1. Start here Welcome aboard What Highport is, what you can do here without an account, and how the rest of this manual is arranged.
  2. Sites that ask who you are What the redirect to a sign-in form does, why a gated image fails silently instead, and the row-by-row account of what the site's owner ends up knowing about you.
  3. When a site is unavailable Seven things a broken site can put on your screen, from "Nothing is published here yet" to a certificate warning, and which of them you can do anything about.
  4. Tiles, from the outside Somebody else's design, running on somebody else's domain. Why it cannot phone home, what its author can still change, and where to browse the ones that exist.

Site owners

For when you want to launch your own site with Highport.

  1. Start here Site owner authentication There is no Highport account. What the handle box does, what your own server's consent screen is agreeing to, and every way a sign-in can fail.
  2. Bringing your domain alongside The two DNS records and which of them proves what, apex domains that cannot take a CNAME, the 168-hour hold on an unverified claim, and every state a registration moves through.
  3. Your first site The editor end to end: what a dropped folder becomes, the seven verdicts that decide whether Publish is available, and what the progress panel is telling you afterwards.
  4. The site record The record field by field. Why the manifest is a lookup table and not a folder, why /docs and /docs/ are two different addresses, and what each entry can carry.
  5. Redirects, missing pages, and being your own handle Redirect targets have to be literal manifest keys, which is the rule that catches nearly everybody. Plus the three statuses a not-found page can take, and the handle collision worth checking for.
  6. Using a tile on your site Where to find a design, what the form its author generated is asking you for, and the eight named refusals you can meet. A binding is by content hash, so nothing moves under you.
  7. Spaces A private record store with a public website on the end of it. How access is granted by members and lapses on its own, the three calls that publish into one, and what disconnecting takes down.
  8. Handing out names under your domain Giving other accounts names under a domain you own: the one wildcard record, reserving a name for someone, the record that quietly breaks a name, certificates one per name or one for all of them, and what sharing a domain between strangers means.
  9. Asking visitors to sign in The prefix list that decides which paths ask a reader to sign in, and why only a hand-written record can set one. What a gated visitor goes through, and what lands in your visitor table.
  10. Limits and quotas Every ceiling with its default and its error name: three domains, twenty tiles, ten thousand manifest entries, a gibibyte a site. Plus how bandwidth is counted and who gets turned away.
  11. Editing, deleting and moving on Four ways to stop, and only one of them cannot be undone. The five record fields the editor quietly drops, what survives a delete, and why asking for a re-index rebuilds nothing.
  12. How your site reaches people Five hops from DNS to your bytes, why a busy domain updates more slowly than an idle one, every cache header we send, and what a proxying CDN in front of us breaks.

Tiles

For when you're having a hard time falling asleep at night.

  1. Start here Tiles The record's five fields, the three files a tile reads at runtime, the five states a version can be in, and why publishing one at all is gated on holding a domain.
  2. Building a tile The Card tile read end to end, from its record to the two functions that fetch a site owner's values. Also the security policy you are writing inside, and the three calls that publish.
  3. Parameters Six types and ten constraints, and which constraint is legal on which type. What each declaration becomes as a form control, and every error a bad one produces on either side.
  4. Versions, edits and the long life of a tile You cannot ship a fix to your existing users, and you cannot withdraw a bad version. Why that is the guarantee rather than the gap, and how to pin an older version by hand.

Advanced

For when something surprises you, or you're writing a tool of your own.

  1. Start here Validate before you write The two-call publish in full: eleven validation steps, twenty manifest rules, every field in the answer, and a runnable transcript from signing in to a page that serves.
  2. How the station notices The pipeline stage by stage, from the Jetstream frame to the pointer swap. Every job state, every rejection, the retry schedule, and how a commit we missed gets picked up anyway.
  3. The origin's rules Nine path-resolution rules in the order they run, the sixteen response headers and the one you control, range requests, and the exact list of types we compress.
  4. The edge Where TLS terminates and a certificate is minted mid-handshake, the ACME budget behind that, how the access gate fails open, and the single log line every byte is billed from.
  5. Safety, and what cannot happen The four fixed headers and the policy behind them, the hash check no caller can skip, the rules a record passes before it serves, and a closing list of what none of this protects you from.
  6. The permission set The permission set your own server shows you, read out entry by entry: the twenty-nine operations it names, where your tokens actually live, and the one method no scope covers at all.
  7. XRPC, and building your own tools All fifty-two methods grouped by who calls them, the three ways to get a token without a browser, the error envelope and the refusals that skip it, and where the schemas resolve from.