Guide
editor-ui limits, local preview, errors
What one publication of the browser editor may carry on each Cloudflare
plan, how to try it on your machine, what it protects, the error answers you
are likely to meet, and what is not built yet. This page continues the
editor guide; the same limits and rules apply to designer-ui
(DESIGNER).
Limits per Cloudflare plan
Cloudflare's Workers limits, as published on 2026-11-15 (Workers limits):
| Workers Free | Workers Paid | |
|---|---|---|
| CPU time per request | 10 ms | 30 s by default, up to 5 min |
| Subrequests per request | 50 | 10,000 |
| Memory per isolate | 128 MB | 128 MB |
| Requests per day | 100,000 | no daily limit |
The worker's own limits come from a measurement made on 2026-11-14 on the
repository layer's code path (Node 25, GitHub replaced by a stand-in; Workers'
own CPU time was not reported by wrangler dev): about 2.5 ms of CPU and
2.4 times the body in memory per MB of image, and files + 5 + folders
requests to GitHub per publication, plus 6 for each retry after another
commit won the race (three attempts at most). One article with a 1 MB image
took 9 requests and about 3.3 ms.
One variable per worker chooses the column: EDITOR_PLAN for editor-ui,
DESIGNER_PLAN for designer-ui, in [vars] of its wrangler.toml.
| Per publication | free (default) |
paid |
|---|---|---|
| Files | 10 | 50 |
| Size of one file | 2 MiB | 10 MiB |
| Size of the whole publication | 2 MiB | 20 MiB |
| Requests to GitHub per call | 45 | 125 |
| Request body (REST and MCP) | 8 MiB | 28 MiB |
Unset or empty means free, which is what every worker deployed before this
variable did, unchanged. Set "paid" only on a Workers Paid account: on
Free, Cloudflare stops an invocation at 50 subrequests and 10 ms of CPU, so
a large publication would fail half-way instead of being refused up front.
Any other value (a typo, "pro") answers 503 {"error": "bad_plan"} on
every path, naming the variable — never a silent fall-back to free.
How the Paid numbers were chosen: a publication costs files + 5 + folders
requests, plus 6 per lost race, three attempts at most, so 50 files in 50
folders with two lost races take 117; the budget keeps the same 8 spare
reads Free keeps (45 against a worst case of 37), 125 in all — far below
Paid's 10,000, because every request also spends the token's GitHub quota.
The body limit is a 20 MiB publication as base64 (26.7 MiB) plus room for
the texts around it; at about 2.4 times the body in memory (the 2026-11-14
measurement) that stays near 67 MB of the isolate's 128 MB.
Over a limit, the answer is 413 too_large with the limits, before anything
is decoded or sent, so the panel can say what to shrink. The panel takes the
limits from the worker (api/site and api/media carry plan and
limits, api/health also the request budget and body size), so it shows
the plan's numbers. The article list loads titles lazily within the request
budget and fills the rest on the next request.
Other limits to know:
- GitHub's rate limit is per token: 5,000 requests an hour for a
personal access token, shared by everyone using the worker. Bind the
optional
RATE_LIMITER(inwrangler.toml, 120 requests a minute per client address as shipped) to keep one client from using it up. - A request body may be at most 8 MiB (28 MiB on
paid), on REST and MCP alike.
Try it on your machine
The demo, with no account and no network
The template ships a local preview that runs the worker's real code against
an in-process stand-in for GitHub, seeded with a small invented site
(five articles in two languages, an image, two earlier publications by two
people). Nothing leaves the machine. It needs Node.js 25 or later, which runs
the TypeScript sources directly. From the site's root, after
ssg new worker editor-ui:
1node --import ./workers/editor-ui/test/resolve.mjs workers/editor-ui/test/dev-server.mjs
Open http://localhost:8789/editor/ and pick an account on the pretend
sign-in page:
| Account | Permissions |
|---|---|
owner |
read, publish, media, delete |
writer |
read, publish, media |
texts |
read, publish (no images) |
reader |
read only |
To see a conflict, open an article, change it, then publish a change to the same article as someone else before you publish yours:
1curl -X POST 'http://localhost:8789/demo/touch?path=content/blog/posts/bread-notes.md'
PORT=… changes the port. The publications land in the stand-in only and
are gone when you stop the server.
Against a test repository with wrangler dev
To try the real thing before deploying, use a throw-away repository with a
copy of your site and a token for that repository only (setup step 2).
The worker trusts only tokens signed by your auth, and the browser session
cookie belongs to your site's host, so locally you call the API with a
service token instead of opening the panel:
-
In the accounts panel of your deployed
auth, create a service account, give it a role witheditor-ui:read, and create a token for it (SERVICE-TOKENS). To publish too, the role needseditor-ui:publish, and the token needs an owner'sallowSensitive. -
In
workers/editor-ui/wrangler.toml, replace<example.com>inrouteswith your host.wrangler devrefuses to start while the placeholder is there ("Cannot infer host from first route"). -
In
workers/editor-ui, put the variables in a file named.dev.vars. Wrangler reads it forwrangler devonly, and its values win over the[vars]ofwrangler.toml. Add.dev.varsand.wrangler/to the site's.gitignore: the file holds the token, andssg initdoes not list either. SetEDITOR_AUTH_AUDIENCEto your site's host, because the tokensauthissues name that host, notlocalhost. The public key is the JSON object afterAUTH_PUBLIC_KEY=, pasted without quotes:1EDITOR_GIT_REPO=github.com/<owner>/<test-repo> 2EDITOR_GIT_BRANCH=main 3EDITOR_GIT_TOKEN=<the fine-grained token> 4EDITOR_AUTH_ISSUER=https://example.com/api/auth 5EDITOR_AUTH_LOGIN_URL=/auth/login 6EDITOR_AUTH_AUDIENCE=example.com 7EDITOR_AUTH_PUBLIC_KEY={"kty":"EC","crv":"P-256","x":"…","y":"…"} -
Start it and call it:
1npx wrangler dev # http://localhost:8787 2ACCESS=$(curl -sf -X POST -H "authorization: Bearer $SSG_SERVICE_TOKEN" \ 3 https://example.com/api/auth/token | jq -r .accessToken) 4curl -s -H "authorization: Bearer $ACCESS" http://localhost:8787/editor/api/health 5curl -s -H "authorization: Bearer $ACCESS" http://localhost:8787/editor/api/content
api/health says what is configured without asking GitHub ("ok": true,
"auth": "auth", the repository and branch); api/me shows the
permissions the token carries; api/content lists the articles of the test
repository. Without a token every route answers 401 with
"reason": "no_session", which shows the worker is up. More calls: EDITOR-API.
What it protects and what it does not
Read this before you hand out permissions. The security review wrote it for
site owners, in the worker's README:
editor-ui: what it protects and what it does not.
In short: the repository token never leaves the worker except to
api.github.com; only Markdown in the content folders and images in the
media folder can be written, never .github/, workers/, wrangler.* or
dot files; nothing overwrites someone else's change. It does not protect your
visitors and administrators from what a publisher writes (raw HTML is
rendered), it does not revoke access in real time, and it cannot stop an AI
assistant from obeying instructions hidden in an article it reads.
Troubleshooting
| Answer | Cause | Fix |
|---|---|---|
503 auth_not_configured on every path |
an EDITOR_AUTH_* value missing, or both or neither of public key and JWKS URL |
set the issuer, the login URL and exactly one of the two |
503 not_configured, "the auth key or issuer is unusable" |
EDITOR_AUTH_PUBLIC_KEY is still the placeholder or not the JSON object auth-keys.mjs printed |
paste the value after AUTH_PUBLIC_KEY= |
401 with "reason": "wrong_audience" |
the token names another host than the request (e.g. wrangler dev on localhost) |
set EDITOR_AUTH_AUDIENCE to the site's host |
503 repo_not_configured |
EDITOR_GIT_REPO or the EDITOR_GIT_TOKEN secret missing or malformed |
detail names the variable (never its value) |
503 site_config_unreadable |
the configuration file uses YAML the small reader does not follow (anchors, <<, | blocks, include:, TOML) |
detail has the file and line; set EDITOR_CONTENT_DIRS and EDITOR_MEDIA_DIR |
503 media_not_configured |
EDITOR_MEDIA_DIR is not a folder ssg publishes |
a folder inside static_dir, or one ending in /media |
502 token_rejected |
the token expired, was revoked, or lacks Contents write on this repository | make a new token (step 2) and wrangler secret put it again |
409 branch_protected |
the branch requires pull requests or status checks | publish to a branch without those rules |
409 conflict / 409 branch_busy |
someone published in between / the branch kept moving | combine and publish again / publish again |
429 rate_limited |
GitHub's limit for the token, or RATE_LIMITER |
wait; retryAt says until when |
403 cross_origin |
a write with the session cookie from another site | publish from the panel on the site's own host |
403 naming a permission |
the account's roles lack it | grant it; it applies within 10 min 30 s |
Not built yet
- Pull requests and preview deployments: a publication is a commit on the configured branch.
- Repository hosts other than GitHub.
- A visual (WYSIWYG) editor or live editing by two people at once; drafts shared between devices.
- Video and files other than images; SVG images.
- OAuth sign-in for remote MCP clients: an MCP client needs an access token from a service token, renewed every 10 minutes.
- Removing a front matter key from the form (edit "Frontmatter as text"
instead);
.markdownfiles; the time of the last change in the list. - Editing
.ssg.yaml, workflows or secrets: never, by design.