Serve published WordPress routes without coordination

Author: chubes4

packages/runtime-cloudflare/README.md

@@ -4,14 +4,16 @@ This candidate integration for [wp-codebox#1838](https://github.com/Automattic/w
 
 ## Runtime Architecture
 
-The entry Worker executes PHP-WASM and WordPress. The named `WordPressStateCoordinator` Durable Object remains lightweight: it serializes a bounded lease and atomically promotes the current canonical R2 pointer with token, base-revision, and version checks. It never imports or instantiates PHP-WASM. State reads query the coordinator directly; every request that can observe canonical WordPress state acquires a lease first.
+The entry Worker executes PHP-WASM and WordPress. The named `WordPressStateCoordinator` Durable Object remains lightweight: it serializes a bounded lease and atomically promotes the current canonical R2 pointer with token, base-revision, and version checks. It never imports or instantiates PHP-WASM. Dynamic state reads query the coordinator directly; explicitly published anonymous routes use the separate reader path described below.
 
 On cold start, the entry Worker uses the acquired pointer to rebuild PHP-WASM's disposable SQLite index from canonical MDI Markdown and JSON files. A missing pointer materializes the packaged canonical MDI seed and boots one PHP-WASM primary runtime. The build-time PHP CLI generator creates that archive from `wordpress-install-seed.sqlite` through MDI's public `bootstrap_existing_cache()` API, validates its pinned MDI revision and input digest, and never packages SQLite. The runtime updates `siteurl` and `home` through WordPress APIs using the request origin and sets the admin password from `WORDPRESS_ADMIN_PASSWORD`; only WordPress's password hash is canonical. Bootstrap persists and CAS-promotes this mutation before serving the next request.
 
 Canonical browser, health, and mutation boots require the separately managed `WORDPRESS_AUTH_SECRET` Worker secret. The entry Worker derives the eight WordPress auth keys and salts from that secret with a versioned, site-scoped (`default`) SHA-256 domain separator before `wp-load.php`. It never logs, persists, or returns the secret or derived values. Configure it independently from the bootstrap password with `wrangler secret put WORDPRESS_AUTH_SECRET --config packages/runtime-cloudflare/wrangler.jsonc`; rotating `WORDPRESS_ADMIN_PASSWORD` does not rotate authentication salts or invalidate sessions.
 
 After each mutating HTTP request, the entry runtime invokes MDI's explicit request-boundary flush, collects canonical files, stores immutable content-addressed R2 objects and a revision manifest, then commits the new pointer through the held lease. GET, HEAD, and asset requests release without promotion. Failed requests abort their leases; stale leases recover by token/version/expiry checks. The entry isolate can cache one runtime only for the exact acquired pointer revision and exits it after promotion or when another isolate advances the pointer. It does not persist SQLite. Existing manifests are reused when canonical file hashes have not changed.
 
+Anonymous HTML responses are stored as create-once, host-independent R2 artifacts under their canonical revision. An authorized `POST ?phase=operator-publish` promotes a bounded, sorted set of already-rendered routes by writing an immutable publication descriptor and then replacing one strongly consistent `sites/default/publications/current.json` pointer. Published GET and HEAD requests check a 60-second edge entry and then the R2 publication before constructing the Durable Object stub; authenticated, preview, admin, REST, and unpublished routes continue through WordPress. Promotion rejects missing, stale, duplicate, malformed, or conflicting artifacts. This is the coordinator-free reader boundary, not yet a complete route compiler or global CDN purge pipeline.
+
 The same revision transaction persists bounded user-managed files under `wp-content/plugins`, `themes`, `languages`, and `mu-plugins`. Runtime-owned MDI, SQLite integration, and Codebox adapter files remain reconstructable artifacts and are excluded. Unchanged bundled-theme files are omitted by release hash, while modified files become canonical overrides. Public canonical plugin and theme assets serve directly from revision-addressed R2 cache entries before the immutable release corpus. Nonce-protected `wp-admin` GET actions such as plugin activation are classified as mutations so their filesystem and MDI option changes commit atomically. Existing revisions without `wpContent` remain valid.
 
 The Worker forwards browser cookies directly to Playground and disables Playground's internal cookie store, preventing an empty per-isolate store from replacing a valid browser session after cold restart.
@@ -29,6 +31,6 @@ Canonical Cloudflare boots patch only the assembled PHP MEMFS copy of `/wordpres
 2. Run `npm run provision:cloudflare-wordpress-runtime-corpus -- --local --persist-to <directory>` to verify and upload all exact content-addressed artifacts into isolated local R2 storage. For an authorized deployment, run the provisioner with `--remote` and require every upload to succeed before deploying the Worker that imports their manifests.
 3. Run `npm run test:cloudflare-runtime` for routing, canonical-state, artifact validation, source contract, and TypeScript coverage.
 4. Run `npm run cloudflare:dry-run` to compile the Worker without creating Cloudflare resources.
-5. Run `npm run cloudflare:local-gate` for isolated local workerd evidence. It generates and provisions all artifacts before workerd starts, then injects stable test-only admin-password and auth-secret values, uploads and activates a real plugin ZIP, verifies that plugin's REST route before and after Worker restart, and covers login, authenticated REST publication, media, public rendering, representative frontend/admin/editor assets, PHP diagnostics, session recovery, and a fresh login after restart.
+5. Run `npm run cloudflare:local-gate` for isolated local workerd evidence. It generates and provisions all artifacts before workerd starts, then injects stable test-only admin-password, auth-secret, and operator-token values, uploads and activates a real plugin ZIP, promotes anonymous homepage and canonical-permalink artifacts, and proves an R2 publication read after Worker restart. It also covers login, authenticated REST publication, media, representative frontend/admin/editor assets, PHP diagnostics, session recovery, and a fresh login after restart.
 
 This document describes local candidate verification only. It does not claim remote deployment.

packages/runtime-cloudflare/src/published-reader.ts

@@ -0,0 +1,77 @@
+export const PUBLISHED_REVISION_SCHEMA = "wp-codebox/published-revision/v1" as const
+export const PUBLISHED_PAGE_SCHEMA = "wp-codebox/wordpress-page/v2" as const
+export const R2_PUBLISHED_CURRENT_KEY = "sites/default/publications/current.json"
+export const R2_PUBLISHED_REVISION_PREFIX = "sites/default/publications/revisions"
+export const MAX_PUBLISHED_ROUTES = 1_000
+export const MAX_PUBLISHED_REVISION_BYTES = 512 * 1024
+export const MAX_PUBLISHED_PAGE_BYTES = 8 * 1024 * 1024
+
+export interface PublishedRoute {
+  route: string
+  objectKey: string
+}
+
+export interface PublishedRevision {
+  schema: typeof PUBLISHED_REVISION_SCHEMA
+  revision: string
+  canonicalRevision: string
+  publishedAt: string
+  routes: PublishedRoute[]
+}
+
+export function canonicalPublicRoute(input: Request | URL | string): string {
+  const url = input instanceof Request ? new URL(input.url) : input instanceof URL ? new URL(input) : new URL(input, "https://wp-codebox-runtime.invalid")
+  url.searchParams.sort()
+  return `${url.pathname}${url.search}`
+}
+
+export async function publishedPageObjectKey(canonicalRevision: string, route: string): Promise<string> {
+  if (!isRevision(canonicalRevision) || !isCanonicalRoute(route)) throw new Error("Published page identity is invalid.")
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(route))
+  const hash = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")
+  return `sites/default/pages/${canonicalRevision}/${hash}.json`
+}
+
+export function publishedRevisionObjectKey(revision: string): string {
+  if (!isRevision(revision)) throw new Error("Published revision identity is invalid.")
+  return `${R2_PUBLISHED_REVISION_PREFIX}/${revision}.json`
+}
+
+export function validatePublishedRevision(value: unknown): PublishedRevision {
+  if (!value || typeof value !== "object") throw new Error("Published revision is invalid.")
+  const revision = value as Partial<PublishedRevision>
+  if (revision.schema !== PUBLISHED_REVISION_SCHEMA || !isRevision(revision.revision) || !isRevision(revision.canonicalRevision)
+    || typeof revision.publishedAt !== "string" || !Number.isFinite(Date.parse(revision.publishedAt)) || !Array.isArray(revision.routes)
+    || revision.routes.length === 0 || revision.routes.length > MAX_PUBLISHED_ROUTES) throw new Error("Published revision is invalid.")
+  let previous = ""
+  for (const route of revision.routes) {
+    if (!route || typeof route !== "object" || !isCanonicalRoute(route.route) || route.route <= previous
+      || route.objectKey !== `sites/default/pages/${revision.canonicalRevision}/${route.objectKey.split("/").at(-1)}`
+      || !/^sites\/default\/pages\/[a-f0-9-]{36}\/[a-f0-9]{64}\.json$/.test(route.objectKey)) throw new Error("Published revision route is invalid.")
+    previous = route.route
+  }
+  return revision as PublishedRevision
+}
+
+export function normalizePublishedRoutes(value: unknown): string[] {
+  if (!Array.isArray(value) || value.length === 0 || value.length > MAX_PUBLISHED_ROUTES) throw new Error("Publication requires a bounded routes array.")
+  const routes = value.map((route) => {
+    if (typeof route !== "string" || !route.startsWith("/")) throw new Error("Publication route is invalid.")
+    return canonicalPublicRoute(route)
+  }).sort()
+  if (routes.some((route, index) => index > 0 && route === routes[index - 1])) throw new Error("Publication routes must be unique.")
+  return routes
+}
+
+function isCanonicalRoute(route: string): boolean {
+  if (!route.startsWith("/") || route.includes("#") || route.includes("\\") || route.length > 2_048) return false
+  try {
+    return canonicalPublicRoute(route) === route
+  } catch {
+    return false
+  }
+}
+
+function isRevision(revision: unknown): revision is string {
+  return typeof revision === "string" && /^[a-f0-9-]{36}$/.test(revision)
+}

packages/runtime-cloudflare/src/request-routing.ts

@@ -5,6 +5,7 @@ export type WorkerRequestRoute =
   | { kind: "r2-mutate" }
   | { kind: "operator-reset" }
   | { kind: "operator-restore" }
+  | { kind: "operator-publish" }
   | { kind: "probe"; phase: string }
 
 export function routeWorkerRequest(request: Request): WorkerRequestRoute {
@@ -15,5 +16,6 @@ export function routeWorkerRequest(request: Request): WorkerRequestRoute {
   if (phase === "r2-mutate") return { kind: "r2-mutate" }
   if (phase === "operator-reset") return { kind: "operator-reset" }
   if (phase === "operator-restore") return { kind: "operator-restore" }
+  if (phase === "operator-publish") return { kind: "operator-publish" }
   return { kind: "probe", phase }
 }