# Hosting the Pine landing page

[Back to Pine](https://pine-pi.vercel.app/index.html) · [Documentation](https://pine-pi.vercel.app/docs/)

Build the site for its final public URL, then host the complete `dist/site/`
directory. Node's built-in modules perform the build; no package installation,
Pine server, model credential or runtime service is needed. The build copies
playback assets, renders the Markdown guides and sets canonical URLs, social
metadata, alternate Markdown links, discovery files and host routing together.

## Build once for the chosen address

From the standalone Pine repository, use Node 22.19 or newer:

```sh
node scripts/build-site.mjs --base-url https://johnlindquist.github.io/pine --lastmod 2026-10-25
node scripts/site-agent-check.mjs dist/site
```

Set `--base-url` to the final HTTPS address, including `/pine` for this GitHub
Pages project. For a root-domain host, pass just that host's HTTPS origin.
Use `--lastmod` for the actual date you changed the published content; the
example date is this content's revision date, not a request to claim a fresh
edit on every deployment. An optional `--out` chooses a different output folder.
The build refuses to overwrite an unrelated directory.

The same source supports GitHub Pages, here.now and Vercel. Rebuild when the
public address changes. Do not edit canonical links or social URLs separately.
Upload the entire output, including `.nojekyll`, `media/`, `vendor/`, the guides,
`robots.txt`, `llms.txt`, `sitemap.xml` and `vercel.json` where that host uses it.

Directory checking validates the files. It reports HTTP statuses and header
negotiation as **not measured**; those require a running URL. The checker emits
JSON, exits 0 when its applicable checks pass, exits 1 for failed checks, and
exits 2 for an invalid invocation or an unreadable target. It is a local
reproducible checker, not an Is Agentic score or a search-ranking test.

## Review over real local HTTP

Serve the generated files with the delivered route interpreter:

```sh
node scripts/build-site.mjs --serve dist/site --profile vercel --port 8080
```

Keep that process running. In another shell, for the GitHub Pages base above:

```sh
node scripts/site-agent-check.mjs http://127.0.0.1:8080/pine/
```

The path prefix comes from the build's base URL. A root-domain build uses `/`
instead. Open the same address in a browser. Inspect desktop and phone widths,
follow Docs and Install Pine, read About, Contact and Privacy, and check a
missing page. Play each workflow, seek while paused, switch tabs, and inspect
the no-JavaScript view. A screenshot or directory pass does not establish that
a deployed server routes requests correctly.

The `vercel` profile is a **local emulation** of the generated ordered routing
rules. It uses a real HTTP server and the delivered `vercel.json`; it is not
Vercel's CDN and does not verify a production deployment. Vercel's configuration
documentation says header `has` conditions are not supported in `vercel dev`,
so that command alone cannot prove Markdown negotiation.

To review the static-host limitation separately, stop the first process and run:

```sh
node scripts/build-site.mjs --serve dist/site --profile static --port 8080
```

In another shell:

```sh
node scripts/site-agent-check.mjs http://127.0.0.1:8080/pine/ --profile static
```

Static mode
reports missing negotiation, `Vary: Accept` and a negotiated Markdown 404 as
expected host limitations. Those checks are still visible in its JSON report.
Do not describe that result as full negotiated-host acceptance.

## Optional GitHub Pages

[github-pages.yml](https://pine-pi.vercel.app/docs/github-pages.yml) is a dormant, opt-in example. Nothing under
`site/docs/` runs as a workflow. The repository owner can copy it to
`.github/workflows/site.yml`, select **GitHub Actions** in **Settings → Pages**,
review the `github-pages` environment and manually start the workflow. There is
no automatic push trigger. The workflow asks for the public base URL and the
content modification date, builds and checks the files, then uploads only
`dist/site/` with GitHub's Pages artifact actions.

The example targets the standalone Pine repository. In a combined workspace,
set the shell steps' working directory to `pine` and the upload path to
`pine/dist/site`. Keep the deployment environment and required `pages: write`
and `id-token: write` permissions.

GitHub Pages can serve the HTML pages, explicit Markdown twins and custom
`404.html`. It cannot run this Vercel routing configuration or select a response
from the `Accept` header. The page's alternate link gives agents a direct
Markdown address, but that is a different capability from negotiation. Verify
its actual Markdown content type and 404 status after publication.

A project site at `/pine/` can publish `/pine/robots.txt`, `/pine/llms.txt` and
`/pine/sitemap.xml`. Crawlers that request only origin-root discovery files will
look at the account's root site instead. If the repository owner also controls
that site, they may link the project sitemap there. A project-level robots file
does not control the whole `johnlindquist.github.io` origin.

## here.now

Publish the complete built directory using the manager's existing here.now
workflow, with its final here.now URL supplied to `--base-url`. This is a static
hosting path with the same negotiation limitation. Confirm the host preserves
the explicit Markdown files and returns a real 404 for an unknown address;
custom 404 handling depends on the host. Use the static profile when checking
the published URL and read every reported limitation.

## Vercel

Build for the intended stable Vercel public URL. Use the generated `dist/site/`
as the static deployment's project root, with its generated `vercel.json` at
that root. There is no framework build inside this directory. The manager can
publish that prebuilt directory through their normal Vercel workflow. A source
repository deployment that ignores the output's configuration will not gain
negotiation; verify the effective root before publishing.

The ordered routes match every page before the filesystem phase. An explicit
`Accept: text/markdown` request with a nonzero quality value selects its Markdown
twin. Ordinary HTML requests retain HTML. Both variants have `Vary: Accept`.
After real assets have a chance to resolve, unknown Markdown requests route to
`404.md` with status 404; other unknown requests route to `404.html` with status
404. Explicit Markdown, XML and text files have their own content types. A
catch-all rewrite returning status 200 would not satisfy the error contract.

The public site lives at https://pine-pi.vercel.app. Its read-only
[Pine API and MCP server](https://pine-pi.vercel.app/docs/api.md) is added to the built directory before
publishing. That step reads the release facts from the published GitHub release:

```sh
node scripts/build-site.mjs --base-url https://pine-pi.vercel.app --lastmod 2026-10-25 --out dist/vercel
node scripts/build-agent-api.mjs --site dist/vercel --base-url https://pine-pi.vercel.app --tag v0.7.0
vercel deploy dist/vercel --prod
```

Run the checker against the actual public URL after the manager publishes it:

```sh
node scripts/site-agent-check.mjs https://your-pine-site.example
```

Replace the example address with the real deployed URL. Inspect the returned
page statuses, negotiated bodies, `Content-Type`, `Vary`, canonical URLs,
sitemap and error responses. Run an Is Agentic scan only after that public
replay. Search discoverability and scanner applicability remain external
measurements. The read-only Pine API and MCP server run only on the Vercel deployment; optional exported
team-agent applications are separate deployments with their own contracts.

## Sources

- [GitHub Pages custom workflows](https://docs.github.com/en/pages/getting-started-with-github-pages/using-custom-workflows-with-github-pages): artifact deployment, configuration and permissions.
- [GitHub setup-node](https://github.com/actions/setup-node): Node setup action and cache configuration.
- [Vercel static configuration](https://vercel.com/docs/project-configuration/vercel-json): ordered routes, headers, conditions and the local `vercel dev` limitation.
- [Vercel build output routing](https://vercel.com/docs/build-output-api/configuration): filesystem and error routing phases.
- [Is Agentic methodology](https://is-agentic.com/methodology): score interpretation, applicability and public-scan limits.
- [Is Agentic developer docs](https://is-agentic.com/docs): Markdown negotiation requirements and public report access.
