create-jant 0.3.39 → 0.3.42

package/template/README.md

@@ -2,239 +2,166 @@
 
 A personal website/blog powered by [Jant](https://github.com/jant-me/jant).
 
-## Option A: One-Click Deploy
+Examples below use `npm`, but the same scripts work with `pnpm run` or `yarn`.
 
-Deploy to Cloudflare instantly — no local setup required:
+## Option A: One-Click Deploy
 
 [![Deploy to Cloudflare](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=https://github.com/jant-me/jant-starter)
 
+Deploy to Cloudflare instantly, without local setup.
+
+In this flow, Cloudflare creates the new GitHub repo, D1 database, and R2 bucket for you from the form.
+
 ### Deploy form fields
 
-| Field                      | What to do                                                                                                                                                 |
-| -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Git account**            | Select your GitHub account. A new repo will be created for you.                                                                                            |
-| **D1 database**            | Keep "Create new". The default name is fine.                                                                                                               |
-| **Database location hint** | Pick a region close to you (optional, Cloudflare auto-selects).                                                                                            |
-| **R2 bucket**              | Keep "Create new". The default name is fine. Used for media uploads.                                                                                       |
-| **AUTH_SECRET**            | Used for login session encryption. Keep the pre-filled value or generate your own with `openssl rand -base64 32`.                                          |
-| **SITE_ORIGIN**            | Optional. Set this when you want a fixed public origin such as `https://my-blog.example.com`. If you leave it empty, Jant uses the current request origin. |
-| **SITE_PATH_PREFIX**       | Optional. Set this only when you mount the site under a subpath such as `/blog`. Leave it empty for normal root deploys.                                   |
+| Field                      | What to do                                                                                                                |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| **Git account**            | Select your GitHub account. Cloudflare creates a new repo for you.                                                        |
+| **D1 database**            | Keep **Create new**. The default name is fine.                                                                            |
+| **Database location hint** | Pick a nearby region if you want. Leaving it alone is fine too.                                                           |
+| **R2 bucket**              | Keep **Create new**. The default name is fine.                                                                            |
+| **AUTH_SECRET**            | Keep the generated value, or replace it with your own 32+ character secret.                                               |
+| **SITE_ORIGIN**            | Optional. Set this when you want a fixed public origin such as `https://my-blog.example.com`.                             |
+| **SITE_PATH_PREFIX**       | Optional. Set this only when you mount the site under a subpath such as `/blog`. Leave it empty for a normal root deploy. |
 
 ### After deploy
 
-1. Visit your site at the URL shown in the Cloudflare dashboard (e.g. `https://<project>.<account>.workers.dev`)
-2. Go to `/setup` to set up your admin account
-3. If you set `SITE_ORIGIN` to a custom domain, add it in: Cloudflare dashboard → Workers & Pages → your worker → Settings → Domains & Routes → Add Custom Domain
-4. If you leave `SITE_ORIGIN` empty, Jant uses your current `*.workers.dev` or custom-domain request host automatically
+1. Open the site URL shown in Cloudflare, usually `https://<project>.<account>.workers.dev`
+2. Go through the setup flow and create your admin account
+3. If you set `SITE_ORIGIN` to a custom domain, add that domain in Cloudflare under **Workers & Pages**
+4. If you leave `SITE_ORIGIN` empty, Jant uses the current request host automatically
 
 ### Develop locally
 
+Cloudflare creates a GitHub repo for you during one-click deploy. To keep working locally:
+
 ```bash
-# Clone the repo that was created for you
 git clone git@github.com:<your-username>/<your-repo>.git
 cd <your-repo>
 npm install
 npm run dev
 ```
 
-Visit http://localhost:3000. Changes pushed to `main` will auto-deploy.
+Open `http://localhost:3000`. Changes pushed to `main` will auto-deploy.
 
-## Option B: Create with CLI
-
-Set up a new project locally, then deploy manually:
+Need another local port? Run:
 
 ```bash
-npm create jant my-site
-cd my-site
-npm run dev
+PORT=3030 npm run dev
 ```
 
-Visit http://localhost:3000. When you're ready to go live, continue with [Deploy to Cloudflare](#deploy-to-cloudflare) below.
-
-Need another local port? Run `PORT=3030 npm run dev`.
+## Option B: Manual Deploy from Your Machine
 
-### Deploy to Cloudflare
+If you would rather create or keep a local site repo and deploy it yourself, use the steps below.
 
-#### 1. Prerequisites
-
-Install [Wrangler CLI](https://developers.cloudflare.com/workers/wrangler/install-and-update/) and log in:
+### 1. Log In to Wrangler
 
 ```bash
-wrangler login
+npx wrangler login
 ```
 
-#### 2. Create D1 Database
-
-Check the `database_name` in your `wrangler.toml` (defaults to `<your-project>-db`), then create it:
+### 2. Create the D1 Database
 
 ```bash
-wrangler d1 create <your-project>-db
-# Copy the database_id from the output!
+npx wrangler d1 create <your-project>-db
 ```
 
-#### 3. Update Configuration
+Copy the `database_id` from the output into `wrangler.toml`.
 
-Edit `wrangler.toml`:
+### 3. Create the R2 Bucket
 
-- Replace `database_id = "local"` with the ID from step 2
-- Set `SITE_ORIGIN` if you want a fixed public origin (e.g. `https://example.com`)
-- Set `SITE_PATH_PREFIX` only if you deploy under a subpath (e.g. `/blog`)
-
-> R2 bucket is automatically created on first deploy — no manual setup needed.
->
-> **Note:** Changing `database_id` resets your local development database (local data is stored per database ID). If you've already started local development, you'll need to go through the setup wizard again to create your admin account.
->
-> **Subpath deploys on Cloudflare:** If `SITE_PATH_PREFIX` is set to `/blog`, Jant publishes built assets under `/blog/_assets/*`. `npm run deploy` detects that prefix and prepares `dist/public/blog/_assets/*` automatically, so routing `/blog*` to the same Worker is enough.
+```bash
+npx wrangler r2 bucket create <your-project>-media
+```
 
-#### 4. Set Production Secrets
+Make sure `wrangler.toml` uses the same bucket name.
 
-Generate a production secret and save it somewhere safe (you'll need it again for CI):
+### 4. Set the Production Auth Secret
 
 ```bash
-# Generate a secret
 openssl rand -base64 32
-
-# Set it in Cloudflare
-wrangler secret put AUTH_SECRET
-# Paste the generated value when prompted
+npx wrangler secret put AUTH_SECRET
 ```
 
-> **Important:** This is separate from the `AUTH_SECRET` in `.dev.vars` (which is for local development only). Do not change the production secret after your site is live — it will invalidate all sessions. If you get locked out, use `npm run reset-password` to generate a password reset link.
+This is separate from the local secret in `.dev.vars`.
 
-#### 5. Deploy
+### 5. Deploy
 
 ```bash
-# Apply database migrations and deploy
 npm run deploy
 ```
 
-Your site is now live at `https://<your-project>.<your-subdomain>.workers.dev`!
-
-#### 6. Custom Domain (Optional)
+After deploy, Cloudflare gives you a `*.workers.dev` URL.
 
-1. Go to [Cloudflare Dashboard](https://dash.cloudflare.com) → Workers & Pages
-2. Select your worker → Settings → Domains & Routes
-3. Click **Add -> Custom domain** and enter your domain
+## Local Development
 
-### GitHub Actions (CI/CD)
-
-A workflow file is included at `.github/workflows/deploy.yml`. Complete the [deployment](#deploy-to-cloudflare) first, then set up CI for automatic deployments.
-
-> Runtime secrets (`AUTH_SECRET`, S3 keys, etc.) are already stored in Cloudflare from the manual deployment step. CI only needs deployment credentials.
-
-#### 1. Push to GitHub
-
-Create a new repository on [GitHub](https://github.com/new), then commit and push your project:
+Start the local dev server:
 
 ```bash
-git add -A
-git commit -m "Initial setup"
-git remote add origin git@github.com:<your-username>/<your-repo>.git
-git push -u origin main
+npm run dev
 ```
 
-#### 2. Create API Token
+Open `http://localhost:3000`.
 
-1. Go to [Cloudflare API Tokens](https://dash.cloudflare.com/profile/api-tokens)
-2. Click **Create Token** → **Use template** next to **Edit Cloudflare Workers**
-3. **Add D1 permission** (not in template by default):
-   - Click **+ Add more** → **Account** → **D1** → **Edit**
+## Common Commands
 
-Your permissions should include:
+| Command                                                | Description                           |
+| ------------------------------------------------------ | ------------------------------------- |
+| `npm run dev`                                          | Start local development               |
+| `npm run deploy`                                       | Apply remote migrations and deploy    |
+| `npm run reset-password`                               | Generate a password reset token       |
+| `npx jant site export --output ./jant-site-export.zip` | Export the site as a portable archive |
 
-| Scope   | Permission         | Access                        |
-| ------- | ------------------ | ----------------------------- |
-| Account | Workers Scripts    | Edit                          |
-| Account | Workers R2 Storage | Edit                          |
-| Account | **D1**             | **Edit** ← Must add manually! |
-| Zone    | Workers Routes     | Edit                          |
+## Configuration
 
-4. Set **Account Resources** → **Include** → your account
-5. Set **Zone Resources** → **Include** → **All zones from an account** → your account
-6. **Create Token** and copy it
+The most common values live in two files:
 
-#### 3. Add GitHub Secrets
+- `.dev.vars` for local secrets
+- `wrangler.toml` for non-sensitive Cloudflare configuration
 
-Go to your repo → **Settings** → **Secrets and variables** → **Actions**:
+Useful examples:
 
-| Secret Name     | Value                                                                    |
-| --------------- | ------------------------------------------------------------------------ |
-| `CF_API_TOKEN`  | API token from above                                                     |
-| `CF_ACCOUNT_ID` | Your Cloudflare Account ID (found in dashboard URL or `wrangler whoami`) |
-
-#### 4. Verify Auto-Deploy
-
-The workflow is pre-configured to deploy on every push to `main`. After pushing your code, check the **Actions** tab in your GitHub repo to confirm the deployment succeeded.
-
-## Commands
-
-| Command                  | Description                                      |
-| ------------------------ | ------------------------------------------------ |
-| `npm run dev`            | Start local dev server (auto-applies migrations) |
-| `npm run deploy`         | Apply remote migrations and deploy               |
-| `npm run reset-password` | Generate a password reset link if locked out     |
-| `npm run export`         | Export D1 database to a SQL file                 |
-
-> Use `--remote` to run commands against your production database (e.g. `npx jant reset-password --remote`).
-
-## Environment Variables
-
-| Variable           | Description                                    | Location         |
-| ------------------ | ---------------------------------------------- | ---------------- |
-| `AUTH_SECRET`      | Secret key for authentication (32+ chars)      | `.dev.vars` file |
-| `SITE_ORIGIN`      | Optional fixed public origin for absolute URLs | `wrangler.toml`  |
-| `SITE_PATH_PREFIX` | Optional public path prefix such as `/blog`    | `wrangler.toml`  |
-
-For all available variables (site name, language, R2 storage, image optimization, S3, demo mode, etc.), see the **[Configuration Guide](https://github.com/jant-me/jant/blob/main/docs/configuration.md)**.
-
-## Customization
-
-### Color Themes
+```toml
+[vars]
+SITE_ORIGIN = "https://yourdomain.com"
+# SITE_PATH_PREFIX = "/blog"
+# R2_PUBLIC_URL = "https://media.yourdomain.com"
+# IMAGE_TRANSFORM_URL = "https://media.yourdomain.com/cdn-cgi/image"
+```
 
-Pick a color theme from the dashboard: **Settings > Appearance**.
+## Documentation
 
-### Custom CSS
+Start here:
 
-Inject custom CSS from the dashboard: **Settings > Appearance > Custom CSS**. This CSS is applied with the highest priority, so you can override any built-in styles.
+- [Introduction](https://github.com/jant-me/jant/blob/main/docs/overview.md)
+- [Deploy on Cloudflare](https://github.com/jant-me/jant/blob/main/docs/deployment.md)
+- [Configuration](https://github.com/jant-me/jant/blob/main/docs/configuration.md)
 
-### Data Attributes
+For writing and customization:
 
-Target specific elements with stable data attributes:
+- [Writing and Organizing Posts](https://github.com/jant-me/jant/blob/main/docs/writing-and-organizing.md)
+- [Theming](https://github.com/jant-me/jant/blob/main/docs/theming.md)
 
-```css
-/* Style only note-format posts */
-[data-format="note"] {
-  border-left: 3px solid var(--primary);
-}
+For operations:
 
-/* Style the home page differently */
-[data-page="home"] {
-  background: var(--muted);
-}
+- [Export and Import](https://github.com/jant-me/jant/blob/main/docs/export-and-import.md)
+- [Backups and Recovery](https://github.com/jant-me/jant/blob/main/docs/backups.md)
 
-/* Hide compose prompt for unauthenticated visitors */
-body:not([data-authenticated]) .compose-prompt {
-  display: none;
-}
-```
+Reference:
 
-## Updating
+- [API Reference](https://github.com/jant-me/jant/blob/main/docs/API.md)
+- [GitHub Repository](https://github.com/jant-me/jant)
 
-```bash
-# Update @jant/core to latest version
-npm install @jant/core@latest
+## AI Coding Tools
 
-# Start dev server (auto-applies migrations locally)
-npm run dev
+This site template includes project guidance in `AGENTS.md` plus task-focused skills in `.agents/skills/`.
 
-# Deploy (includes remote migrations)
-npm run deploy
-```
+For concrete content automation examples, see `examples/agent-content-automation/README.md`.
 
-> New versions of `@jant/core` may include database migrations. Check the [release notes](https://github.com/jant-me/jant/releases) for any breaking changes.
+Available skills:
 
-## Documentation
+- `building-jant-site`
+- `jant-http-api`
+- `jant-site-ops`
 
-- [Configuration Guide](https://github.com/jant-me/jant/blob/main/docs/configuration.md)
-- [Theming Guide](https://github.com/jant-me/jant/blob/main/docs/theming.md)
-- [GitHub Repository](https://github.com/jant-me/jant)
+If your coding tool expects Claude-style project files, `CLAUDE.md` and `.claude/skills/` are generated too.

package/template/_github/workflows/deploy.yml

@@ -34,13 +34,47 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
+      - name: Check deploy prerequisites
+        id: preflight
+        env:
+          CF_API_TOKEN: ${{ secrets.CF_API_TOKEN }}
+          CF_ACCOUNT_ID: ${{ secrets.CF_ACCOUNT_ID }}
+        run: |
+          set -eu
+
+          if [ -z "${CF_API_TOKEN}" ] || [ -z "${CF_ACCOUNT_ID}" ]; then
+            echo "ready=false" >> "$GITHUB_OUTPUT"
+            {
+              echo "### Deploy skipped"
+              echo
+              echo "Add \`CF_API_TOKEN\` and \`CF_ACCOUNT_ID\` in GitHub Actions secrets to enable auto-deploy."
+            } >> "$GITHUB_STEP_SUMMARY"
+            exit 0
+          fi
+
+          database_id="$(sed -n 's/^database_id = "\\([^"]*\\)".*/\\1/p' wrangler.toml | head -n 1)"
+
+          if [ -z "${database_id}" ] || [ "${database_id}" = "local" ]; then
+            echo "ready=false" >> "$GITHUB_OUTPUT"
+            {
+              echo "### Deploy skipped"
+              echo
+              echo "Replace the placeholder D1 \`database_id\` in \`wrangler.toml\` before enabling auto-deploy."
+            } >> "$GITHUB_STEP_SUMMARY"
+            exit 0
+          fi
+
+          echo "ready=true" >> "$GITHUB_OUTPUT"
+
       - name: Run migrations
+        if: steps.preflight.outputs.ready == 'true'
         run: npx wrangler d1 migrations apply DB --remote
         env:
           CLOUDFLARE_API_TOKEN: ${{ secrets.CF_API_TOKEN }}
           CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CF_ACCOUNT_ID }}
 
       - name: Deploy to Cloudflare Workers
+        if: steps.preflight.outputs.ready == 'true'
         uses: cloudflare/wrangler-action@v3
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}

package/template/examples/agent-content-automation/README.md

@@ -0,0 +1,92 @@
+# Agent Content Automation
+
+This folder shows the shortest path for content automation in a generated Jant site.
+
+Prefer the local CLI when the agent is already on the site machine. Use MCP only when the caller already speaks MCP.
+
+## Publish a note from JSON
+
+```bash
+npx jant posts create --input ./examples/agent-content-automation/note.json
+```
+
+## Publish a quote from JSON
+
+```bash
+npx jant posts create --input ./examples/agent-content-automation/quote.json
+```
+
+## Update site settings from JSON
+
+```bash
+npx jant settings update --input ./examples/agent-content-automation/site-settings.json
+```
+
+## Upload an image, then attach it to a post
+
+Upload the file:
+
+```bash
+npx jant media upload ./path/to/photo.webp --alt "Cover image"
+```
+
+That returns a `med_*` ID. Use it in a post payload:
+
+```json
+{
+  "format": "note",
+  "title": "A post with media",
+  "bodyMarkdown": "Uploaded through the local CLI.",
+  "status": "published",
+  "visibility": "public",
+  "attachments": [{ "type": "media", "mediaId": "med_..." }]
+}
+```
+
+Then publish it:
+
+```bash
+npx jant posts create --json '{"format":"note","title":"A post with media","bodyMarkdown":"Uploaded through the local CLI.","status":"published","visibility":"public","attachments":[{"type":"media","mediaId":"med_..."}]}'
+```
+
+## Inline text attachments stay in the post payload
+
+File uploads create reusable media records. Inline reading notes and markdown snippets stay inside the post payload itself:
+
+```json
+{
+  "format": "note",
+  "bodyMarkdown": "A note with an attached markdown excerpt.",
+  "status": "published",
+  "visibility": "public",
+  "attachments": [
+    {
+      "type": "text",
+      "contentFormat": "markdown",
+      "content": "## Reading note\n\nKeep this attached to the post."
+    }
+  ]
+}
+```
+
+## MCP example
+
+Initialize:
+
+```bash
+curl -X POST "$JANT_URL/api/mcp" \
+  -H "Authorization: Bearer $JANT_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -H "MCP-Protocol-Version: 2025-06-18" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18"}}'
+```
+
+Create a post through `tools/call`:
+
+```bash
+curl -X POST "$JANT_URL/api/mcp" \
+  -H "Authorization: Bearer $JANT_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -H "MCP-Protocol-Version: 2025-06-18" \
+  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"jant_posts_create","arguments":{"format":"note","bodyMarkdown":"Created through MCP.","status":"published","visibility":"public"}}}'
+```

package/template/examples/agent-content-automation/note.json

@@ -0,0 +1,7 @@
+{
+  "format": "note",
+  "title": "A short note",
+  "bodyMarkdown": "Published through the local CLI example.",
+  "status": "published",
+  "visibility": "public"
+}

package/template/examples/agent-content-automation/quote.json

@@ -0,0 +1,9 @@
+{
+  "format": "quote",
+  "quoteText": "What stands in the way becomes the way.",
+  "sourceName": "Marcus Aurelius",
+  "sourceUrl": "https://example.com/meditations",
+  "bodyMarkdown": "A source-backed quote published through the CLI example.",
+  "status": "published",
+  "visibility": "public"
+}

package/template/examples/agent-content-automation/site-settings.json

@@ -0,0 +1,5 @@
+{
+  "SITE_NAME": "Example Jant Site",
+  "SITE_DESCRIPTION": "Automated through the local CLI example.",
+  "TIME_ZONE": "Asia/Shanghai"
+}

package/template/package.json

@@ -12,6 +12,6 @@
     "@jant/core": "workspace:*"
   },
   "devDependencies": {
-    "wrangler": "^4.76.0"
+    "wrangler": "catalog:"
   }
 }

package/template/wrangler.toml

@@ -24,7 +24,7 @@ port = 3000
 [vars]
 # Optional: Pin your site's public origin (e.g. https://my-blog.example.com)
 # https://github.com/jant-me/jant/blob/main/docs/configuration.md#public-urls-and-subpaths
-SITE_ORIGIN = "https://demo.jant.me" # @create-jant: "https://example.com"
+SITE_ORIGIN = "https://demo.jant.me" # @create-jant: @remove
 # Optional: Mount the site under a subpath such as /blog
 # SITE_PATH_PREFIX = "/blog"
 

package/template/docs/internal/migrate.md

@@ -1,10 +0,0 @@
-# Demo Public Migration
-
-```
-mise run demo-public-rebuild
-```
-
-This is the canonical rebuild path for `demo.jant.me`. It imports the committed
-snapshot from `sites/demo-source/canonical/snapshot/`.
-
-See `sites/demo/docs/internal/operations.md` for the full public-demo workflow.

package/template/docs/internal/operations.md

@@ -1,61 +0,0 @@
-# Demo Public Operations
-
-`sites/demo` is the public demo runtime at `demo.jant.me`.
-
-The daily operational commands still live in the root `mise.toml` because the
-workflow crosses both `sites/demo-source` and `sites/demo`, and `sites/demo`
-also doubles as the starter template source.
-
-## Common Commands
-
-```sh
-mise run demo-public-bootstrap
-mise run demo-public-rebuild
-mise run demo-public-verify
-mise run demo-public-clear-content
-mise run demo-public-clear-api-tokens
-```
-
-## Environment Files for Repo Tasks
-
-Repo-level demo tasks now auto-load:
-
-1. `sites/demo/.env.local`
-2. `sites/demo/.env`
-3. repo root `.env.repo.local`
-4. repo root `.env.repo`
-5. legacy repo root `.env.local`
-6. legacy repo root `.env`
-
-Shell environment variables still win over all of them.
-
-Recommended split:
-
-- repo root `.env.repo.local`: `CLOUDFLARE_API_TOKEN`, `CLOUDFLARE_ACCOUNT_ID`
-  Start from [/.env.repo.example](/Users/green/project/jant/main/.env.repo.example).
-- [`sites/demo/.env.example`](/Users/green/project/jant/main/sites/demo/.env.example):
-  copy to `.env.local` for `INTERNAL_ADMIN_TOKEN`, plus any local
-  overrides such as `DEMO_PUBLIC_URL`, `DEMO_EMAIL`, or `DEMO_PASSWORD`
-
-## Expected Flow
-
-1. Curate content in `demo-source`.
-2. Freeze it with `mise run demo-source-export-canonical`.
-3. Review and commit `sites/demo-source/canonical/snapshot/`.
-4. Publish it to `demo-public` with `mise run demo-public-rebuild`.
-5. Let `.github/workflows/reset-demo.yml` re-run the same rebuild nightly.
-
-## Notes
-
-- `demo-public-rebuild` is snapshot-based. It no longer imports the old static
-  site export.
-- `demo-public-rebuild` keeps a standalone storage cleanup step before import.
-  That cleanup exists so demo maintenance can enforce its own storage policy
-  separately from the normal snapshot restore contract.
-- `demo-public-rebuild` also clears every user-created API token through
-  `INTERNAL_ADMIN_TOKEN`, so demo tokens are disposable across nightly
-  resets.
-- The rebuild workflow still imports the canonical snapshot with an explicit
-  remap intent rather than relying on implicit single-site behavior.
-- `db-demo-reseed` remains as a compatibility alias for
-  `mise run demo-public-rebuild`.

package/template/static-site-export/README.md

@@ -1,70 +0,0 @@
-# Jant Demo — Zola Export
-
-This is a static site exported from [Jant](https://github.com/jant-me/jant), ready to build with [Zola](https://www.getzola.org/).
-
-## Install Zola
-
-**macOS (Homebrew):**
-
-```sh
-brew install zola
-```
-
-**Windows (Scoop):**
-
-```sh
-scoop install zola
-```
-
-**Linux (Snap):**
-
-```sh
-snap install zola --edge
-```
-
-Or download a binary from <https://github.com/getzola/zola/releases>.
-
-See the [Zola installation docs](https://www.getzola.org/documentation/getting-started/installation/) for more options.
-
-## Quick start
-
-Preview locally:
-
-```sh
-zola serve
-```
-
-Then open <http://127.0.0.1:1111> in your browser.
-
-Build the site for deployment:
-
-```sh
-zola build
-```
-
-The output goes to the `public/` directory. Upload it to any static host (Netlify, Vercel, Cloudflare Pages, GitHub Pages, etc.).
-
-## Project structure
-
-```
-config.toml          — Site configuration (title, URL, language)
-content/
-  _index.md          — Root section (homepage settings)
-  {slug}/index.md    — Individual posts (threads are merged into one page)
-templates/           — Tera templates (Zola's template engine)
-static/
-  style.css          — Stylesheet
-```
-
-## Customizing
-
-- **Site settings** — edit `config.toml` to change the title, URL, or language.
-- **Styles** — edit `static/style.css`. The theme supports light and dark modes via `prefers-color-scheme`.
-- **Templates** — edit files in `templates/`. Zola uses the [Tera](https://keats.github.io/tera/) template engine.
-- **Collections** — posts are tagged with collections via the `c` taxonomy. Browse them at `/c/`.
-
-## Notes
-
-- Media files (images, etc.) are **not** included in the export. They link back to the original site.
-- Thread replies are merged into the root post as a single page. Reply metadata is preserved in HTML comments (`<!-- jant:reply ... -->`).
-- Posts with `draft: true` in front matter are only built when you pass the `--drafts` flag to `zola build` or `zola serve`.