=== Kinto Static ===
Contributors: kintoco
Tags: static site, cloudflare pages, static html, performance, security
Requires at least: 6.4
Tested up to: 7.1
Requires PHP: 7.4
Stable tag: 1.0.0
License: GPLv2 or later
License URI: https://www.gnu.org/licenses/gpl-2.0.html

Turn your WordPress site into static files and publish them to Cloudflare Pages in a few clicks. Free, no command line needed.

== Description ==

Not affiliated with or endorsed by Cloudflare, Inc.

Kinto Static makes a fast, safe, static copy of your WordPress site and puts it online on Cloudflare Pages, which has a free plan. You keep editing in WordPress as always. When you are ready, press **Publish** and your visitors get plain files instead of a PHP site that has to be kept patched.

There is no GitHub account to create and no command line. You connect with one click (**Connect with Cloudflare**), see a preview of your static site on a separate address before you publish it, and an optional **Your domain** step walks you through putting your own domain name on it.

**How it works**

1. **Connect with Cloudflare.** You agree to let the plugin talk to Cloudflare, click **Connect with Cloudflare**, sign in (a free account is enough) and press Allow. Nothing to copy or paste. If you prefer, or your site cannot use one-click connect (for example a local test site), you can paste an access key instead. Either way the credentials are stored encrypted and never shown in your browser again.
2. **Check your site.** The plugin checks that your site can be exported (permalinks, memory and time limits, estimated number of files) and tells you in plain language what will stop working on a static copy.
3. **Preview, then publish.** You first get a separate preview address to look at your static site. It is not linked from your real site, but anyone who has the link can open it, so don't share it if the content is not ready. When you like it, press **Publish** to put it online. You see live progress, can cancel, and can resume if something goes wrong. Later publishes upload only the files that changed.
4. **Your domain (optional).** Put your own domain name on the static site. See the FAQ below for what it does.
5. **Report a problem.** If something fails, you can send a small report to the developers after previewing exactly what it contains. Nothing is sent without your confirmation.

**Search that keeps working**

On a static copy, WordPress search normally stops working. Kinto Static includes a built-in **Search** add-on, on by default:

* Click, tap or type in your theme's own search box, open a `/?s=term` or `/search/term/` address, or press Ctrl/Cmd+K, and a full-screen search panel opens with instant results: title, a type label, a highlighted snippet, and image, price and date when the page has them.
* When one section of a page clearly answers the question, an **Answer** card jumps straight to that part of the page.
* It works with the block search, classic themes, Divi, Elementor, WooCommerce product search and more.
* Accents and capital letters don't matter, small typos are tolerated, and the panel works with the keyboard and screen readers.
* The index is built when you publish, from the pages that are already public. Nothing private and nothing from wp-admin goes into it. It is stored in your site's own files, under `/_kinto/search/`.
* No external service, no tracking and no cookies. You can turn it off on the **Add-ons** page.

Limits: very large sites get a trimmed index (about 6 MB), there are no AI answers, and custom search forms with their own filters (real estate or shop filters, for example) are not replaced.

**Contact forms that keep working**

The optional **Kinto Forms** add-on (off by default) makes the contact forms of Contact Form 7, Elementor Pro, WPForms Lite, Divi and plain HTML forms keep working on the static copy:

* It runs in **your own Cloudflare account**: a small Worker made by this plugin receives the forms and emails them to you, and nothing goes through Kinto.
* There is no address to confirm and no confirmation email: the Worker sends from a sending address of your own domain straight to the address you give, and the plugin ends the setup with one test message to you.
* It sends nothing until you press **Turn on** on the **Add-ons** page and confirm what will be created in your Cloudflare account. See "External services" below.
* Forms with file uploads and other form builders are reported as not working, as before.

**What stops working on a static site**

A static site is a set of ready-made pages. Anything that needs WordPress to think at the moment a visitor arrives cannot work by itself:

* Forms that send data to your server, except the contact forms **Kinto Forms** can take over (see above). Other forms stop working.
* Comments (existing comments are shown, new ones cannot be posted; an add-on for comments is planned).
* Site search, only if you turn the built-in Search add-on off. It is on by default.
* Shopping carts, checkout and payments (for example WooCommerce).
* Logins, memberships and members-only content.
* Anything that is personalised per visitor or changes every second.

Your WordPress site stays exactly where it is, so you can keep using it to edit. Only the published copy is static. If your site depends on the features above, a static copy is probably not right for you yet.

**Free**

The plugin is free and open source, and Cloudflare Pages has a free plan that covers most small sites. There is no paid tier and no account with Kinto.

Kinto Static is an independent plugin. It is not made, endorsed or sponsored by Cloudflare, Inc.

== Installation ==

1. Upload the plugin folder to `/wp-content/plugins/`, or install it from the Plugins screen in WordPress.
2. Activate the plugin through the **Plugins** screen.
3. Open **Kinto Static** in the admin menu and follow the steps on the screen.

You can also use WP-CLI: `wp kinto-static status`, `wp kinto-static export`, `wp kinto-static publish`.

== Frequently Asked Questions ==

= Can I use my own domain name? =

Yes. Your published site always works at a free `*.pages.dev` address, and the **Your domain** step (it appears after your first publish) takes you from there to your own domain, such as `yourbusiness.com`, in plain steps:

1. **Cloudflare takes over your domain's DNS.** Cloudflare's free plan hosts your domain's DNS records. The plugin helps you add the domain, copies the records you already have (so your email keeps working) and shows the two nameserver values to paste at the company where you bought the domain, with step-by-step guides for the common registrars.
2. **WordPress moves to `wp.yourbusiness.com`.** Your public domain is going to show the static site, so your WordPress editor needs an address of its own. The plugin helps you create that address, waits until it answers over a valid HTTPS certificate, and only then switches WordPress to it. You sign in again there. Before switching it shows you (and emails the site admin) the two `wp-config.php` lines that bring the old address back.
3. **Go live.** After one more publish (so every address inside the pages says your domain) you press **Turn on**. Your domain and the `www` version then point at the static site.
4. **Undo with one click.** An **Undo** button puts your previous DNS records back, one piece at a time, and the old WordPress address can be restored.

Requirements and limits in version 1.0:

* A Cloudflare account (free) with the domain added to it, and access to the place where the domain is registered to change its nameservers. Registrar changes can take from minutes up to 48 hours; your site and email keep working meanwhile.
* The `wp.yourbusiness.com` address is created automatically on cPanel hosting that allows it, or by you with a short guide (manual subdomain) on any other host. It must point at the same folder as your main site and have an HTTPS certificate (a free AutoSSL or Let's Encrypt one is enough); the plugin never moves WordPress to an address without a valid certificate.
* WordPress installed in a subfolder (for example `yourbusiness.com/blog`) is not supported in this version; the step is not offered there.
* Sites that fix their address with `WP_HOME` / `WP_SITEURL` in `wp-config.php`, or a `COOKIE_DOMAIN` that does not cover `wp.yourbusiness.com`, need those lines edited by hand first. The plugin tells you when that is the case.
* If DNSSEC is on for the domain, turn it off first.
* Unusual DNS setups are refused with an explanation instead of being changed: a custom SPF range or macros, a CAA record that excludes Cloudflare's certificate authorities, or a name with hundreds of records. Nothing is modified in that case.

= How does the plugin read my domain's DNS? =

The "Your domain" step asks the web server's own DNS resolver for the public records of your domain (the same records anyone can look up), to suggest your registrar and to find records that are missing in Cloudflare. No external service is involved and nothing is sent anywhere for this. If your host blocks DNS lookups, the step still works: you choose your registrar yourself.

= I can't log in to WordPress after the domain step. =

The step moves your WordPress address to `wp.yourdomain.com`, and only after that address answers over a valid HTTPS certificate. Before it does, it shows you (and emails the site admin) two lines for `wp-config.php`. If you are ever locked out, add them above the line that says "That's all, stop editing" to bring back the old address:

`define( 'WP_HOME', 'https://yourdomain.com' );`
`define( 'WP_SITEURL', 'https://yourdomain.com' );`

With WP-CLI: `wp kinto-static domain revert-wp` puts the previous address back, and `wp kinto-static domain status` shows where the step stands. Note that the old address only works while your domain still points at WordPress, so undo the go-live step first.

= What happens to my WordPress admin? =

Nothing, unless you use the **Your domain** step. WordPress keeps running where it is and you keep editing there; the static copy is separate. If you put your main domain on the static site, WordPress moves to its own `wp.yourdomain.com` address first, so you never lose access to wp-admin. That is why the step does not just point your domain at the static site on its own.

= Does search work on the static site? =

Yes. The built-in Search add-on is on by default. Visitors who use your theme's search box, open a `/?s=term` address or press Ctrl/Cmd+K get a full-screen panel with instant results, and an **Answer** card when one section of a page clearly answers the question. The index is built when you publish from your already-public pages only, and it lives in your own files under `/_kinto/search/`. It uses no external service, no tracking and no cookies. Very large sites get a trimmed index (about 6 MB), there are no AI answers, and custom search forms with their own parameters (for example real estate or shop filters) are not replaced. You can turn it off on the **Add-ons** page.

= Are there limits? =

Yes, they come from Cloudflare Pages' free plan: at most 20,000 files per publish and 25 MiB per file. The plugin warns you before publishing if your site is likely to go over, and lists files that are too large.

= Which hosting panels work? =

Publishing to Cloudflare Pages does not depend on your hosting panel. What changes is moving WordPress to `wp.yourdomain.com`: on cPanel the plugin does it for you; on CloudPanel, Plesk, hPanel, DirectAdmin, CyberPanel, HestiaCP, aaPanel or a VPS without a panel it shows you the steps to follow. In the Settings box you can tell us which panel to automate next.

= Does it work on cheap shared hosting? =

It is designed for it. Long work is split into small steps so it fits in short request times and low memory limits, and it can resume if a step is interrupted.

= What data does the plugin send, and where? =

Only to the services listed in "External services" below, and only after you agree. It never starts sending on its own schedule: it only continues what you began (a publish, "Turn on" or Undo finishing in the background, and the "Your domain" screen or the Kinto Forms card checking progress while it is open), and it has no tracking or statistics. The built-in Search add-on uses no external service: the index is made from your public pages when you publish and is served from your own site's files.

= Does Kinto Forms keep my visitors' messages? =

No. Messages go to a Worker in your own Cloudflare account and never touch Kinto. Cloudflare sends the email under its own privacy policy. The visitor's IP address is used only, salted and hashed, as the key of short rate limits against abuse. Once Kinto Forms is set up, the plugin adds a suggested paragraph to your site's privacy policy guide (Settings, Privacy); it goes away when you turn Kinto Forms off and remove it.

= Does it store my Cloudflare credentials safely? =

The access key (or, with Connect with Cloudflare, the access and renewal tokens) is encrypted in your database and is only used from your server. It is not sent to your browser. You can disconnect at any time, and you should also delete the key in your Cloudflare dashboard if you stop using the plugin.

= A page looks different on the static copy. =

Tell us with **Report a problem**. Reports help us fix compatibility with themes and page builders.

== Screenshots ==

1. Connect with Cloudflare: one button, and a clear consent before anything leaves your site.
2. Review: what we found on your site, and your free address.
3. Preview: see how your site will look, then publish it.
4. Published: your site is live, with its address ready to open or copy.
5. Your domain: step by step, the two nameservers to paste at your registrar.

== Changelog ==

= 1.0.0 =
* First public release.
* One-click **Connect with Cloudflare** (or paste an access key), with account picker.
* Check your site, preview the static copy, then publish to Cloudflare Pages; later publishes upload only changed files.
* **Your domain** step: Cloudflare DNS, WordPress moved to `wp.yourdomain.com` (automatic on cPanel, guided elsewhere), go-live and one-click undo.
* Problem reports (with preview and consent) and WP-CLI commands.
* Built-in **Search** add-on (on by default): instant full-screen search on the static site, with no external service. Turn it off on the **Add-ons** page.
* Spanish (es_ES) translation included.
* Optional **Kinto Forms** add-on: contact forms keep working on the static site, running in your own Cloudflare account; off by default and only after you agree.

== Upgrade Notice ==

= 1.0.0 =
First release. Connect with Cloudflare in one click, preview your static site, publish it, and optionally put your own domain on it.

== External services ==

This plugin can connect to six external services, each described below: Cloudflare's API, Cloudflare's sign-in, three Kinto services (the connect relay, problem reports, and the hosted forms service, which is off in this version and never contacted), and, when you turn on Kinto Forms, Cloudflare Turnstile. Nothing is sent to any of them until you agree, and nothing starts until you click to begin it; an open "Your domain" screen, or an open Kinto Forms card that is waiting for its test message, continues a step you began. The only background work is finishing a publish, "Turn on" or Undo that you started (WP-Cron). Calls to your own website are listed at the end.

= Cloudflare API =

Used to publish your static site to Cloudflare Pages and, in the "Your domain" step, to set up your domain.

* Service: the Cloudflare API at `https://api.cloudflare.com/` (Cloudflare, Inc.).
* What is sent and when: only after you tick the consent box in step 1 of the plugin. The plugin sends your credentials (the access token from Connect with Cloudflare, or your access key) to check that they work and to list your Cloudflare accounts, Pages projects and domains. It creates the Pages project you choose, uploads the files of your static site (your generated pages, images, styles and scripts, plus a file list with their hashes) and creates a deployment. This also happens when you press **Preview**: the preview is a deployment on Cloudflare Pages, so the site files are uploaded to Cloudflare at that point, before you publish. In the optional "Your domain" step it also reads and changes the DNS records of the domain you enter (adding the domain, copying missing records, pointing the domain and `www` at your Pages project, and restoring the previous records on Undo) and attaches the domain to your Pages project. It also issues and revokes a Cloudflare origin certificate for `wp.yourdomain.com` (a certificate request is sent; the private key is not), and creates and removes an SSL rule and a www redirect rule on your Cloudflare zone. These requests happen when you connect, when you press Publish or run the equivalent WP-CLI command, and while you use the "Your domain" step (the screen checks its progress about every 20 seconds while it is open). If you close the page during a publish, "Turn on" or Undo that you started, WordPress finishes it in the background (WP-Cron), sending the same kind of requests to Cloudflare; nothing else is sent in the background.
* Permissions requested, both with Connect with Cloudflare and in the access key link: `page` (Cloudflare Pages: publish your site), `account_settings` (read, to list your accounts), and, for the "Your domain" step only, `zone`, `dns`, `ssl_and_certificates`, `config_settings` (Config Rules) and `dynamic_redirect` (Single Redirect). Cloudflare grants them to the whole account, so the connection can edit every domain in it; the plugin changes only the domain you enter in the "Your domain" step. Connect with Cloudflare asks for the equivalent scopes (Cloudflare names them differently, for example `page.write` and `zone.write`), plus read access to your user details and `offline_access`, which lets the plugin renew the token.
* If you turn on Kinto Forms (an optional add-on, after its own confirmation), it is installed in your own Cloudflare account and the plugin also uses the Cloudflare API to: register your account's workers.dev address if it has none (it belongs to the whole account and is not removed later); upload the forms Worker (a small script shipped inside this plugin, whose readable source is in the `forms-worker/src` folder of https://github.com/1511170/kinto-wp-static) with your email address, your site's host names, your language and your spam-filter and message settings, and upload it again when you change the address or settings or when you publish and your host names changed; switch the Worker on at its workers.dev address; set up a sending address for your domain: it switches Cloudflare Email Sending on for `mail.<your domain>`, or for `forms-mail.<your domain>` if the first name is already in use in your DNS or in Email Sending (the forms email is sent from `forms@` that name, the only kind of address Cloudflare lets a Worker send from), which makes Cloudflare add six DNS records under that name (none at your domain itself; your existing records and your domain's email are not touched, and a name that already has records is never used), and turns off the copy of message bodies that Cloudflare keeps in its dashboard by default; create a Turnstile widget for your site's addresses, named after your site's host (see below), and, only on a site whose owner has switched on the experimental copies and automatic replies options (off by default in this version and not shown in the Forms card), a SQLite Durable Object inside that same Worker that holds the reply counters (one reply per sender per day, and the copies and the replies together count against an hourly limit held in that Durable Object; Cloudflare charges nothing extra on its free plan; the Worker also receives a random per-install salt as a secret). The plugin does NOT add any Email Routing address, and no email address is registered or confirmed anywhere: Cloudflare Email Sending accepted sending from your domain's sending address to your address, and also to copy addresses and to visitors who get an automatic reply when those experimental options are switched on, without any confirmation. All of these messages are sent from that same sending address. At the end of the setup the plugin sends a test form from your server to your own Worker at `https://<worker>.<your-subdomain>.workers.dev/`, which emails you one test message. If Cloudflare's new sending address is not answering yet, the plugin tries again, up to 6 tries in all over about 26 minutes, and only while the Forms card is open in your admin (the card's own polling drives the tries; nothing runs in the background). A "Send a test" button repeats the test, but it is not offered once the extra spam check (Turnstile) is live, because a test sent from your server carries no Turnstile token and the Worker would refuse it. Turning forms off deletes the Worker (and with it its Durable Object), the Turnstile widget, and the sending address with the DNS records under it (a sending address that was already there is left alone); removing the plugin deletes the Worker, but the sending address with its DNS records and any Turnstile widget stay in your Cloudflare account until you remove them in Cloudflare. The key needs the permissions Workers Scripts (edit), Email Sending (edit) and Turnstile Sites (edit), on top of the DNS and zone access the plugin already has for your domain. If you connected with Cloudflare's sign-in, the Forms card asks you to approve the extra permissions once (the OAuth scopes `workers-scripts`, `email-sending` and `challenge-widgets`). The hosted forms service (`forms.kinto.co`) is not offered in this version (see "Kinto Forms hosted service" below).
* Terms of service: https://www.cloudflare.com/terms/
* Privacy policy: https://www.cloudflare.com/privacypolicy/

= Cloudflare sign-in (OAuth) =

Used only for "Connect with Cloudflare". It is never used with an access key.

* Service: Cloudflare's sign-in service at `https://dash.cloudflare.com/oauth2/` (Cloudflare, Inc.).
* What is sent and when: only after you tick the consent box and click **Connect with Cloudflare**. Your browser goes to Cloudflare to sign in and approve access. Your server then sends the one-time code it gets back (with its PKCE secret) to `dash.cloudflare.com/oauth2/token` to receive an access token and a renewal token, renews the access token about once an hour while it is used, and revokes the connection (`dash.cloudflare.com/oauth2/revoke`) when you press Disconnect.
* Terms of service: https://www.cloudflare.com/terms/
* Privacy policy: https://www.cloudflare.com/privacypolicy/

= Kinto connect relay =

Used only when you click **Connect with Cloudflare**, to bring you back to your site after you approve access at Cloudflare. It is never used with an access key.

* Service: `https://connect.kinto.co/` (Kinto LLC).
* What is sent and when: only after you tick the consent box and click **Connect with Cloudflare**. Your browser is sent to the relay with your wp-admin address (where to return you), a random one-time value and a PKCE challenge (a hash; the secret it comes from stays on your server). When Cloudflare sends you back, the relay passes the one-time authorization code through to your site. The relay never receives your access or renewal token or the PKCE secret, stores nothing and keeps no logs of these values.
* Terms of service: https://kinto.co/kinto-static/terms/
* Privacy policy: https://kinto.co/kinto-static/privacy/

= Kinto Forms hosted service (off in this version) =

The plugin's code contains a client for a hosted Kinto Forms service, but it is switched off in 1.0: nothing in the admin offers it and the plugin makes no request to it, not even to refresh an old record. It can only be switched on by a developer through the filter `kinto_wps/forms_hosted`.

* Service: `https://forms.kinto.co/` (Kinto LLC).
* What is sent and when: only if a developer has turned the service on with that filter, and only after the site owner ticks its consent box and registers: the owner's email address, the site name, the site's host names, the site's language (`locale`) and the plugin version are sent to register the site, and later the same host names or address when they change, and the registration is deleted when forms are turned off. Nothing is sent by default.
* Terms of service: https://kinto.co/kinto-static/terms/
* Privacy policy: https://kinto.co/kinto-static/privacy/

= Kinto problem reports =

Used only if you choose to report a problem or send a panel choice in Settings.

* Service: Kinto's report service at `https://feedback.kinto.co/v1/reports` (Kinto LLC).
* What is sent and when: for a problem report, only when you click **Report a problem**, read the preview and tick the consent box. The report contains the category you pick, your optional description, sent as you typed it except that percent codes such as %20 are removed, a lone `<` is shown as `&lt;`, and email addresses, IP addresses, tokens, long opaque strings, home-directory file paths, HTML tags and URL query strings or fragments are replaced automatically (please do not type private data there; you can read and edit the whole report before it is sent), the plugin, WordPress and PHP versions, the active theme and any page builder or cache, SEO, security or multilingual plugin from a fixed list, the page path, and the deployment id and stage, plus the error code if the last publish failed. If you use "Which panel should we automate next?" in Settings, only that choice is sent (the panel you pick, or the name you type), after you tick its consent box and press Send, together with a random report id, a consent flag and a fixed placeholder theme value (`none`); it contains nothing about your site. Reports are kept for 180 days. The automatically collected fields contain no site address or user names, no full plugin list, cookies or page content, and no identifier of your site is sent. Nothing is sent before you confirm.
* Terms of service: https://kinto.co/kinto-static/terms/
* Privacy policy: https://kinto.co/kinto-static/privacy/

= Cloudflare Turnstile (extra spam check for Kinto Forms) =

Used when you turn on Kinto Forms, which runs in your own Cloudflare account: the plugin always tries to add a Turnstile widget, and if it cannot, the forms still work with their other spam checks. Turnstile is a Cloudflare service that checks that a visitor is not a bot before a form is sent.

* Service: Cloudflare Turnstile, script `https://challenges.cloudflare.com/turnstile/v0/api.js` and verification at `https://challenges.cloudflare.com/turnstile/v0/siteverify` (Cloudflare, Inc.).
* What is sent and when: your published pages do not contact Cloudflare Turnstile at all unless the widget exists. When you turn on Kinto Forms, your server asks the Cloudflare API (under the Cloudflare consent you already gave) to create a Turnstile widget in your own account for your site's addresses; after your next publish has put the widget on your pages, it hands the widget's secret to your forms Worker. Turning forms off tries to delete the widget. The key it needs is the extra permission "Turnstile Sites: Edit". On your published site, only on pages that contain a form, the visitor's browser then loads the script from `challenges.cloudflare.com` and runs the check; Cloudflare receives what the browser sends for any web request (such as its IP address) plus browser signals used to tell people from bots. When the visitor sends the form, the resulting token goes to your forms Worker, which verifies it with `challenges.cloudflare.com/turnstile/v0/siteverify`. Nothing is sent on a schedule and nothing is sent to Kinto.
* Terms of service: https://www.cloudflare.com/website-terms/
* Privacy policy: https://www.cloudflare.com/privacypolicy/

= Your own website and your own domain =

These are not third-party services; they are listed so nothing is hidden.

* Your server asks your own website for its pages when it builds the static copy, and starts WordPress's own background task (`wp-cron.php`) on your site to keep a publish going.
* While a publish finishes, your server requests the new address of your Pages deployment (`https://<name>.pages.dev/`, a Cloudflare address) about every 5 seconds, for up to 10 minutes, to confirm it answers over valid HTTPS before telling you it is ready. The request carries only a time value in the query and the usual headers, no cookies or site data.
* In the "Your domain" step, before moving WordPress to `wp.yourdomain.com`, your server makes a few requests to that address (your own site, on your own hosting) to confirm it answers over a valid HTTPS certificate and is this WordPress site. The request contains a random test value and no personal data.
* When you press "Turn on" in that step, your server also requests your project's `pages.dev` address once, and then your domain and `www.yourdomain.com` (Cloudflare serves them) until each answers over valid HTTPS with your site's own marker header. These are plain page requests with no cookies or site data.
* If a publish finished but its address did not answer within those 10 minutes, your browser (not your server) asks that `pages.dev` address about every 10 seconds, with `fetch` in `no-cors` mode so the answer is never read, until it answers; the links stay off until then.
* In the "Your domain" step, just before WordPress is moved, your browser makes one request, also `no-cors` and without cookies, to `https://wp.yourdomain.com/?kinto_wps_ping=<random token>` so your server can confirm that your own browser can reach the new address.
* The step also looks up your domain's public DNS records with your web server's own resolver (the same records anyone can look up) and, on cPanel hosting, runs cPanel's local `uapi` command on the same server through PHP `exec()` to create the `wp.` address and to install its certificate; installing the certificate briefly puts its private key in a temporary file (permissions 0600) that is deleted afterwards. It first runs when you press Create in this step. After that, while the "Your domain" screen is open and the address or its certificate is not ready, the screen checks progress and requests the certificate by itself, so the command can also run when you return to that screen. It also removes the certificate when you press Start over or change the domain in this step, and `wp kinto-static domain check` and `domain revert-wp` can run it from WP-CLI. It does not run on any other screen, and the background work (WP-Cron) never runs it. No other service is involved.

= Search on your static site =

The built-in Search add-on is not an external service. Its index is built on your server when you publish, from your already-public pages, and the search runs entirely in the visitor's browser from files on your own site (`/_kinto/search/`). Nothing is sent to Kinto, Cloudflare (beyond the normal publishing of your files) or anyone else, and it sets no cookies.

= Links that open in your browser =

These are ordinary links you click; your server sends nothing to these sites. Your browser opens them, so the address you click is visible to them like any link.

* **Create access key** opens `dash.cloudflare.com/profile/api-tokens` (Cloudflare). The address carries the permissions the key needs and a suggested key name that includes your site's hostname (for example "Kinto Static – example.com").
* In the "Your domain" step, the button to open your registrar goes to that company's account page for managing nameservers, one of: `ap.www.namecheap.com`, `www.namecheap.com`, `dcc.godaddy.com`, `hpanel.hostinger.com`, `www.spaceship.com`, `porkbun.com`, `account.squarespace.com`, `my.ionos.com`, `www.networksolutions.com` or `dash.cloudflare.com`. The addresses are fixed, except that the Namecheap link includes your domain name.
* The "No Cloudflare account yet? Create one free" link, shown when connecting did not work, opens `dash.cloudflare.com/sign-up`.

== Third-party libraries and credits ==

* **MiniSearch** 7.2.0 (https://github.com/lucaong/minisearch), MIT license, by Luca Ongaro. Included as `assets/search/minisearch.js` with its license in `assets/search/minisearch-LICENSE.txt`. The only change is to its UMD wrapper, so that it registers a private global instead of a generic one and cannot clash with other scripts on your site.
