Add files using upload-large-folder tool

tasks/zennioptical/solution/site/README.md

@@ -0,0 +1,4 @@
+# Oracle support
+
+The materializer assembles the frozen clone, backend, and reference adapter as
+the private implementation. No additional oracle-only behavior is required.

tasks/zennioptical/solution/site/implementation/Dockerfile

@@ -0,0 +1,7 @@
+FROM python:3.12-slim
+WORKDIR /srv/reference
+COPY . .
+ENV HOST=0.0.0.0 PORT=8080 DATA_DIR=/tmp/websitebench-zennioptical-reference-data SEED=0 TZ=UTC
+RUN ./compile.sh
+HEALTHCHECK --interval=2s --timeout=3s --retries=30 CMD python3 -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/healthz', timeout=2)"
+CMD ["./executable"]

tasks/zennioptical/solution/site/implementation/README.md

@@ -0,0 +1,5 @@
+# Direct reference adapter
+
+The materializer overlays these ABI files on the frozen Zenni Optical clone and
+backend. The same assembled bytes form the private oracle implementation; the
+clone and backend are not duplicated in this authoring directory.

tasks/zennioptical/solution/site/implementation/backend/model.json

@@ -0,0 +1,435 @@
+{
+  "schema_version": "offline-clone.backend-model.v1",
+  "site_id": "zennioptical",
+  "status": "draft",
+  "profile": "offline-benchmark",
+  "database": {
+    "engine": "sqlite",
+    "location_policy": "runtime-data-outside-candidate",
+    "concurrency_model": "wal-transactional-single-writer",
+    "migration_strategy": "versioned-forward-migrations",
+    "deterministic_reset": true,
+    "restart_persistence": true,
+    "site_isolation": "one-database-per-site",
+    "proofs": [
+      {
+        "obligation": "data-location",
+        "status": "planned",
+        "evidence": []
+      },
+      {
+        "obligation": "schema-migration",
+        "status": "planned",
+        "evidence": []
+      },
+      {
+        "obligation": "deterministic-reset",
+        "status": "planned",
+        "evidence": []
+      },
+      {
+        "obligation": "restart-persistence",
+        "status": "planned",
+        "evidence": []
+      },
+      {
+        "obligation": "backup-restore",
+        "status": "planned",
+        "evidence": []
+      },
+      {
+        "obligation": "concurrency",
+        "status": "planned",
+        "evidence": []
+      }
+    ]
+  },
+  "auth_semantics": {
+    "account_database_scope": "site-isolated",
+    "credential_storage": "salted-scrypt-hash",
+    "session_storage": "opaque-cookie-digest-at-rest",
+    "registration_account_creation": "after-email-verification",
+    "verification_challenge_storage": "salted-hash",
+    "password_reset_enumeration": "indistinguishable-public-response",
+    "mail_default": "LOCAL_ONLY",
+    "mail_statuses": [
+      "LOCAL_ONLY",
+      "SMTP_PENDING",
+      "SMTP_SENT",
+      "SMTP_FAILED"
+    ],
+    "smtp_activation": "explicit-complete-config-only",
+    "smtp_delivery_ceiling": 3,
+    "rejected_secret_journaling": "forbidden",
+    "legacy_write_policy": "read-compatible-write-rejected"
+  },
+  "common_capabilities": {
+    "account_registration": "account-registration",
+    "account_sign_in": "account-sign-in",
+    "session_lifecycle": "session-lifecycle",
+    "password_recovery": "password-recovery",
+    "email_delivery": "email-delivery"
+  },
+  "capabilities": [
+    {
+      "id": "account-registration",
+      "label": "Verified local account registration",
+      "priority": "p0",
+      "category": "authentication",
+      "implementation_status": "planned",
+      "entities": [
+        {
+          "name": "pending-registration",
+          "identity": "opaque pending id bound to one browser session",
+          "owner_scope": "session",
+          "persistence": "durable"
+        },
+        {
+          "name": "local-account",
+          "identity": "site-local account id and unique normalized email",
+          "owner_scope": "account",
+          "persistence": "durable"
+        }
+      ],
+      "state_machine": {
+        "kind": "challenge-lifecycle",
+        "states": [
+          "collecting",
+          "pending-verification",
+          "verified",
+          "account-created",
+          "expired",
+          "locked"
+        ],
+        "transitions": [
+          {
+            "from": "collecting",
+            "to": "pending-verification",
+            "trigger": "validated registration request"
+          },
+          {
+            "from": "pending-verification",
+            "to": "verified",
+            "trigger": "correct unexpired code within attempt budget"
+          },
+          {
+            "from": "verified",
+            "to": "account-created",
+            "trigger": "transactional account creation and session rotation"
+          },
+          {
+            "from": "pending-verification",
+            "to": "expired",
+            "trigger": "challenge expiry"
+          },
+          {
+            "from": "pending-verification",
+            "to": "locked",
+            "trigger": "verification attempt budget exhausted"
+          }
+        ]
+      },
+      "server_authorities": [
+        "The server normalizes identity and hashes password and code.",
+        "An account is created only after successful verification.",
+        "Duplicate normalized email creation is rejected transactionally."
+      ],
+      "external_effect": "none",
+      "journey_ids": [],
+      "invariant_ids": [],
+      "proofs": {
+        "evidence": {},
+        "planned": [
+          "valid",
+          "invalid",
+          "duplicate",
+          "stale",
+          "foreign-owner",
+          "unauthorized-role",
+          "restart",
+          "migration",
+          "concurrency"
+        ],
+        "not_applicable": []
+      }
+    },
+    {
+      "id": "account-sign-in",
+      "label": "Password-based local account sign-in",
+      "priority": "p0",
+      "category": "authentication",
+      "implementation_status": "planned",
+      "entities": [
+        {
+          "name": "local-account",
+          "identity": "site-local account id and normalized email",
+          "owner_scope": "account",
+          "persistence": "durable"
+        }
+      ],
+      "state_machine": {
+        "kind": "entity-lifecycle",
+        "states": [
+          "signed-out",
+          "identified",
+          "authenticated",
+          "rejected"
+        ],
+        "transitions": [
+          {
+            "from": "signed-out",
+            "to": "identified",
+            "trigger": "normalized email submitted"
+          },
+          {
+            "from": "identified",
+            "to": "authenticated",
+            "trigger": "constant-time password verification succeeds"
+          },
+          {
+            "from": "identified",
+            "to": "rejected",
+            "trigger": "credentials are invalid"
+          }
+        ]
+      },
+      "server_authorities": [
+        "The server verifies salted password hashes.",
+        "The server rotates the authenticated session.",
+        "Client-selected fixture identity is not authentication."
+      ],
+      "external_effect": "none",
+      "journey_ids": [],
+      "invariant_ids": [],
+      "proofs": {
+        "evidence": {},
+        "planned": [
+          "valid",
+          "invalid",
+          "duplicate",
+          "stale",
+          "foreign-owner",
+          "unauthorized-role",
+          "restart",
+          "migration",
+          "concurrency"
+        ],
+        "not_applicable": []
+      }
+    },
+    {
+      "id": "session-lifecycle",
+      "label": "Anonymous and authenticated browser sessions",
+      "priority": "p0",
+      "category": "authentication",
+      "implementation_status": "planned",
+      "entities": [
+        {
+          "name": "browser-session",
+          "identity": "opaque cookie token with digest persisted at rest",
+          "owner_scope": "session",
+          "persistence": "durable"
+        }
+      ],
+      "state_machine": {
+        "kind": "session-lifecycle",
+        "states": [
+          "anonymous",
+          "authenticated",
+          "revoked",
+          "expired"
+        ],
+        "transitions": [
+          {
+            "from": "anonymous",
+            "to": "authenticated",
+            "trigger": "successful sign-in or registration rotates session"
+          },
+          {
+            "from": "authenticated",
+            "to": "revoked",
+            "trigger": "sign-out or security reset"
+          },
+          {
+            "from": "anonymous",
+            "to": "expired",
+            "trigger": "session expiry"
+          },
+          {
+            "from": "authenticated",
+            "to": "expired",
+            "trigger": "session expiry"
+          }
+        ]
+      },
+      "server_authorities": [
+        "Raw session tokens are never stored in the database.",
+        "Ownership is resolved from the server-side session record.",
+        "Sign-out revokes server-side authority before deleting the cookie."
+      ],
+      "external_effect": "none",
+      "journey_ids": [],
+      "invariant_ids": [],
+      "proofs": {
+        "evidence": {},
+        "planned": [
+          "valid",
+          "invalid",
+          "duplicate",
+          "stale",
+          "foreign-owner",
+          "unauthorized-role",
+          "restart",
+          "migration",
+          "concurrency"
+        ],
+        "not_applicable": []
+      }
+    },
+    {
+      "id": "password-recovery",
+      "label": "Enumeration-resistant local password recovery",
+      "priority": "p0",
+      "category": "authentication",
+      "implementation_status": "planned",
+      "entities": [
+        {
+          "name": "password-reset-challenge",
+          "identity": "opaque reset id bound to one browser session",
+          "owner_scope": "session",
+          "persistence": "durable"
+        },
+        {
+          "name": "local-account",
+          "identity": "nullable concealed account binding",
+          "owner_scope": "account",
+          "persistence": "durable"
+        }
+      ],
+      "state_machine": {
+        "kind": "challenge-lifecycle",
+        "states": [
+          "requested",
+          "verified",
+          "consumed",
+          "expired",
+          "locked"
+        ],
+        "transitions": [
+          {
+            "from": "requested",
+            "to": "verified",
+            "trigger": "correct unexpired code within attempt budget"
+          },
+          {
+            "from": "verified",
+            "to": "consumed",
+            "trigger": "password is replaced and sessions are revoked"
+          },
+          {
+            "from": "requested",
+            "to": "expired",
+            "trigger": "challenge expiry"
+          },
+          {
+            "from": "requested",
+            "to": "locked",
+            "trigger": "verification attempt budget exhausted"
+          }
+        ]
+      },
+      "server_authorities": [
+        "Known and unknown emails receive indistinguishable public responses.",
+        "Only the server binds a reset flow to an account.",
+        "Password replacement revokes prior authenticated sessions."
+      ],
+      "external_effect": "local-only",
+      "journey_ids": [],
+      "invariant_ids": [],
+      "proofs": {
+        "evidence": {},
+        "planned": [
+          "valid",
+          "invalid",
+          "duplicate",
+          "stale",
+          "foreign-owner",
+          "unauthorized-role",
+          "restart",
+          "migration",
+          "concurrency"
+        ],
+        "not_applicable": []
+      }
+    },
+    {
+      "id": "email-delivery",
+      "label": "Truthful local verification and recovery mail outbox",
+      "priority": "p0",
+      "category": "communication",
+      "implementation_status": "planned",
+      "entities": [
+        {
+          "name": "mail-outbox-entry",
+          "identity": "site-local outbox id and purpose-bound flow id",
+          "owner_scope": "system",
+          "persistence": "durable"
+        }
+      ],
+      "state_machine": {
+        "kind": "delivery-lifecycle",
+        "states": [
+          "local-only",
+          "smtp-pending",
+          "smtp-sent",
+          "smtp-failed"
+        ],
+        "transitions": [
+          {
+            "from": "local-only",
+            "to": "smtp-pending",
+            "trigger": "operator enables complete explicit SMTP configuration"
+          },
+          {
+            "from": "smtp-pending",
+            "to": "smtp-sent",
+            "trigger": "SMTP transport confirms delivery handoff"
+          },
+          {
+            "from": "smtp-pending",
+            "to": "smtp-failed",
+            "trigger": "delivery attempt fails or ceiling is reached"
+          },
+          {
+            "from": "smtp-failed",
+            "to": "smtp-pending",
+            "trigger": "bounded idempotent retry below the delivery ceiling"
+          }
+        ]
+      },
+      "server_authorities": [
+        "Offline mode records LOCAL_ONLY and never claims external delivery.",
+        "SMTP is disabled unless every required setting is present.",
+        "Claim, retry, and startup replay share one delivery ceiling."
+      ],
+      "external_effect": "local-only",
+      "journey_ids": [],
+      "invariant_ids": [],
+      "proofs": {
+        "evidence": {},
+        "planned": [
+          "valid",
+          "invalid",
+          "duplicate",
+          "stale",
+          "foreign-owner",
+          "unauthorized-role",
+          "restart",
+          "migration",
+          "concurrency"
+        ],
+        "not_applicable": []
+      }
+    }
+  ]
+}

tasks/zennioptical/solution/site/implementation/backend/runtime.json

@@ -0,0 +1,105 @@
+{
+  "database": {
+    "data_dir": "data",
+    "engine": "sqlite",
+    "filename": "zennioptical.sqlite3",
+    "legacy_unbound_migration": false,
+    "migration_hook": "zenni.schema:migrate",
+    "seed_hook": "zenni.schema:seed",
+    "volume_identity": "websitebench-zennioptical-data"
+  },
+  "deployment": {
+    "profiles": {
+      "cloudflare-review": {
+        "mail_adapter": "redis-resend",
+        "payment_adapter": "local-sandbox",
+        "persistence": "ephemeral-reset"
+      },
+      "docker-volume": {
+        "mail_adapter": "effects-gateway",
+        "payment_adapter": "local-sandbox",
+        "persistence": "persistent-volume"
+      },
+      "offline-harbor": {
+        "mail_adapter": "local-outbox",
+        "payment_adapter": "local-sandbox",
+        "persistence": "persistent"
+      }
+    }
+  },
+  "mail": {
+    "purposes": {
+      "password-reset": {
+        "body": "Your password reset code is ${code}.",
+        "expiry": "This code expires in ${minutes} minutes.",
+        "footer": "Ignore this message if you did not contact Zenni Optical.",
+        "lead": "A password reset was requested for Zenni Optical.",
+        "required_variables": [
+          "code",
+          "minutes"
+        ],
+        "secret_variables": [
+          "code"
+        ],
+        "subject": "Reset your Zenni Optical password",
+        "template_id": "zennioptical.password-reset.v1"
+      },
+      "registration": {
+        "body": "Your verification code is ${code}.",
+        "expiry": "This code expires in ${minutes} minutes.",
+        "footer": "This code is only for Zenni Optical.",
+        "lead": "Finish creating your Zenni Optical account.",
+        "required_variables": [
+          "code",
+          "minutes"
+        ],
+        "secret_variables": [
+          "code"
+        ],
+        "subject": "Verify your Zenni Optical account",
+        "template_id": "zennioptical.registration.v1"
+      }
+    },
+    "sender": {
+      "address_env": "RESEND_FROM_EMAIL",
+      "display_name": "Zenni Optical"
+    }
+  },
+  "payments": {
+    "currency": "USD",
+    "default_adapter": "local-sandbox",
+    "enabled": false,
+    "local_sandbox": {
+      "scenarios": [
+        {
+          "display_label": "Simulated approval",
+          "id": "sandbox-approved",
+          "outcome": "approved"
+        },
+        {
+          "display_label": "Simulated decline",
+          "id": "sandbox-declined",
+          "outcome": "declined"
+        },
+        {
+          "display_label": "Simulated retry",
+          "id": "sandbox-retry",
+          "outcome": "retryable"
+        }
+      ]
+    },
+    "stripe_test": null
+  },
+  "schema_version": "websitebench.site-backend-runtime.v1",
+  "session": {
+    "host_only": true,
+    "http_only": true,
+    "same_site": "Lax",
+    "secure": true
+  },
+  "site": {
+    "id": "zennioptical",
+    "label": "Zenni Optical",
+    "public_origin": "https://zennioptical.offline.invalid"
+  }
+}

tasks/zennioptical/solution/site/implementation/clone/app.py

@@ -0,0 +1,1917 @@
+"""Zenni Optical offline clone.
+
+Every route, control and state below was walked on the source with Playwright;
+all data, accounts, mail and payments stay inside this site's local backend.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from html import escape
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlencode
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from fastapi import FastAPI, Form, Request
+from fastapi.responses import HTMLResponse, RedirectResponse, Response
+from fastapi.staticfiles import StaticFiles
+
+from backend.site_backend_integration import open_site_services
+from websitebench.site_backend.errors import PaymentRejected
+from zenni import (accessories, catalog, lenses, nav, render, reviews,
+                   store)
+from zenni import home as home_content
+from zenni.render import money, page
+from zenni.schema import reset as reset_site_rows
+
+SITE_ID = "zennioptical"
+DISPLAY_NAME = "Zenni Optical"
+
+app = FastAPI(title=DISPLAY_NAME)
+app.mount(
+    "/static",
+    StaticFiles(directory=str(Path(__file__).resolve().parent / "static")),
+    name="static",
+)
+
+def _bind_sandbox_data_dir() -> None:
+    """Honour the isolation contract's writable data directory.
+
+    Under ``verify --section live`` the candidate root is mounted read-only and
+    the sandbox hands the process ``WEBSITEBENCH_DATA_DIR``; the site database
+    has to live there instead of beside the frozen contracts.
+    """
+
+    if os.environ.get("WEBSITEBENCH_SITE_BACKEND_DATABASE"):
+        return
+    data_dir = os.environ.get("WEBSITEBENCH_DATA_DIR")
+    if not data_dir:
+        return
+    runtime = json.loads(
+        (Path(__file__).resolve().parents[1] / "backend" / "runtime.json")
+        .read_text(encoding="utf-8"))
+    target = Path(data_dir) / runtime["database"]["filename"]
+    target.parent.mkdir(parents=True, exist_ok=True)
+    os.environ["WEBSITEBENCH_SITE_BACKEND_DATABASE"] = str(target)
+
+
+_bind_sandbox_data_dir()
+BACKEND, AUTH = open_site_services()
+COOKIE = BACKEND.session_cookie
+SEED_ACCOUNTS = [
+    {
+        "subject_id": "zenni-shopper",
+        "email": "shopper@zennioptical.offline.invalid",
+        "display_name": "Sandbox Shopper",
+        "password": "OfflineClone!2026",
+        "email_verified": True,
+    },
+]
+
+# Routes that the source only serves to a signed-in session.
+AUTH_REQUIRED_PREFIXES = ("/b/", "/p/", "/search", "/orderProcess",
+                          "/shoppingCart", "/orderCheckout", "/myAccount",
+                          "/tryon")
+
+
+def _seed_accounts() -> None:
+    for account in SEED_ACCOUNTS:
+        if not AUTH.account_exists(email=account["email"]):
+            AUTH.seed_account(
+                subject_id=account["subject_id"], email=account["email"],
+                display_name=account["display_name"],
+                password=account["password"], email_verified=True,
+            )
+
+
+_seed_accounts()
+
+
+def connection():
+    return AUTH.connect()
+
+
+class Ctx:
+    """Per-request session, account and cart facts."""
+
+    def __init__(self, request: Request) -> None:
+        token = request.cookies.get(COOKIE["name"])
+        self.token, self.session = AUTH.ensure_session(token)
+        self.new_cookie = self.token != token
+        resolved = AUTH.resolve_session(self.token) or {}
+        self.account = resolved.get("account") or resolved.get("subject")
+        if isinstance(self.account, str):
+            self.account = {"subject_id": self.account}
+        self.subject_id = (self.account or {}).get("subject_id")
+        self.display_name = (self.account or {}).get("display_name") or "there"
+
+    def state(self, connection_) -> dict[str, Any]:
+        return {
+            "account": self.account,
+            "cart_count": store.cart_count(connection_, self.token),
+            "display_name": self.display_name,
+        }
+
+
+def respond(ctx: Ctx, html: str, status: int = 200) -> HTMLResponse:
+    response = HTMLResponse(html, status_code=status)
+    _stamp(ctx, response)
+    return response
+
+
+def redirect(ctx: Ctx, location: str, status: int = 303) -> RedirectResponse:
+    response = RedirectResponse(location, status_code=status)
+    _stamp(ctx, response)
+    return response
+
+
+def _stamp(ctx: Ctx, response: Response) -> None:
+    if not ctx.new_cookie:
+        return
+    # Keep the runtime cookie contract intact: the ``__Host-`` prefix is only
+    # accepted with Secure set, and browsers treat 127.0.0.1 as a trustworthy
+    # origin, so the review target over loopback HTTP still stores it.
+    options = {k: v for k, v in COOKIE.items() if k != "name"}
+    response.set_cookie(COOKIE["name"], ctx.token, **options)
+
+
+def _login_redirect(ctx: Ctx, request: Request) -> RedirectResponse:
+    state = str(request.url.path)
+    if request.url.query:
+        state += "?" + request.url.query
+    return redirect(ctx, "/login?" + urlencode({"state": state}), status=302)
+
+
+def _requires_auth(path: str) -> bool:
+    return any(path.startswith(prefix) for prefix in AUTH_REQUIRED_PREFIXES)
+
+
+# --------------------------------------------------------------------------
+# Diagnostics
+
+
+@app.get("/healthz")
+def healthz() -> dict[str, object]:
+    return {"ok": True, "site_id": SITE_ID}
+
+
+@app.post("/__reset__")
+def reset_state() -> dict[str, object]:
+    """Deterministic reset so a review run always starts from seed."""
+
+    AUTH.reset_site_state(
+        site_reset=reset_site_rows, seed_accounts=SEED_ACCOUNTS)
+    return {"ok": True, "site_id": SITE_ID, "state": "seeded"}
+
+
+# --------------------------------------------------------------------------
+# Authentication
+
+
+@app.get("/login", response_class=HTMLResponse)
+def login_form(request: Request, state: str = "/", error: str = "") -> Response:
+    ctx = Ctx(request)
+    if ctx.account:
+        return redirect(ctx, state or "/")
+    demo = SEED_ACCOUNTS[0]
+    banner = f'<p class="flash error">{escape(error)}</p>' if error else ""
+    body = (
+        '<div class="wrap auth"><h1 class="page">Account Login</h1>'
+        f"{banner}"
+        '<form method="post" action="/login">'
+        f'<input type="hidden" name="state" value="{escape(state)}">'
+        '<label>Email<input name="email" type="email" required '
+        'autocomplete="username"></label>'
+        '<label>Password<input name="password" type="password" required '
+        'autocomplete="current-password"></label>'
+        '<button class="zenbtn zenbtn-primary zenbtn-large" '
+        'data-testid="sign-in">Sign in</button></form>'
+        '<p class="muted">New here? <a href="/register">Create an account</a>'
+        "</p>"
+        '<div class="sandbox"><strong>Local sandbox account</strong><br>'
+        f'{escape(demo["email"])}<br>{escape(demo["password"])}<br>'
+        "No real Zenni credential is accepted or stored here.</div></div>"
+    )
+    return respond(ctx, page("Account Login | Zenni Optical", body,
+                             ctx.state(connection())))
+
+
+@app.post("/login")
+def login_submit(request: Request, email: str = Form(...),
+                 password: str = Form(...), state: str = Form("/")) -> Response:
+    ctx = Ctx(request)
+    old_token = ctx.token
+    try:
+        result = AUTH.sign_in(ctx.token, email=email, password=password)
+    except Exception:
+        return redirect(
+            ctx,
+            "/login?" + urlencode(
+                {"state": state, "error": "Email or password is incorrect."}),
+        )
+    token = result.get("session_token") or ctx.token
+    ctx.token, ctx.new_cookie = token, True
+    resolved = AUTH.resolve_session(token) or {}
+    account = resolved.get("account") or {}
+    store.adopt_session(connection(), old_token, token,
+                        account.get("subject_id"))
+    return redirect(ctx, state or "/")
+
+
+@app.get("/register", response_class=HTMLResponse)
+def register_form(request: Request, error: str = "") -> Response:
+    ctx = Ctx(request)
+    banner = f'<p class="flash error">{escape(error)}</p>' if error else ""
+    body = (
+        '<div class="wrap auth"><h1 class="page">Create your account</h1>'
+        f"{banner}"
+        '<form method="post" action="/register">'
+        '<label>Name<input name="display_name" required></label>'
+        '<label>Email<input name="email" type="email" required></label>'
+        '<label>Password<input name="password" type="password" required '
+        'minlength="10"></label>'
+        '<button class="zenbtn zenbtn-primary zenbtn-large">Create account'
+        "</button></form>"
+        '<div class="sandbox">Verification mail is written to this site\'s '
+        "local outbox; nothing is sent to a real address.</div></div>"
+    )
+    return respond(ctx, page("Create Account | Zenni Optical", body,
+                             ctx.state(connection())))
+
+
+@app.post("/register")
+def register_submit(request: Request, display_name: str = Form(...),
+                    email: str = Form(...), password: str = Form(...)) -> Response:
+    ctx = Ctx(request)
+    try:
+        AUTH.start_registration(
+            ctx.token, email=email, display_name=display_name,
+            password=password, restart_invalid_flow=True)
+    except Exception as error:  # surfaced to the shopper, never swallowed
+        return redirect(
+            ctx, "/register?" + urlencode({"error": str(error)[:160]}))
+    return redirect(ctx, "/register/verify")
+
+
+@app.get("/register/verify", response_class=HTMLResponse)
+def register_verify_form(request: Request, error: str = "") -> Response:
+    ctx = Ctx(request)
+    try:
+        mail = AUTH.local_mail_for_session(
+            ctx.token, purpose="registration") or []
+    except Exception:
+        mail = []
+    if isinstance(mail, dict):
+        mail = [mail]
+    outbox = "".join(
+        f"<li>{escape(str(entry.get('subject', 'Verification email')))}</li>"
+        for entry in mail if isinstance(entry, dict)
+    )
+    banner = f'<p class="flash error">{escape(error)}</p>' if error else ""
+    body = (
+        '<div class="wrap auth"><h1 class="page">Verify your email</h1>'
+        f"{banner}"
+        '<form method="post" action="/register/verify">'
+        '<label>Verification code<input name="code" required '
+        'inputmode="numeric"></label>'
+        '<button class="zenbtn zenbtn-primary zenbtn-large">Verify</button>'
+        "</form>"
+        f'<div class="sandbox">Local outbox<ul>{outbox or "<li>(empty)</li>"}'
+        "</ul>Open the site outbox to read the code; it never leaves this "
+        "machine.</div></div>"
+    )
+    return respond(ctx, page("Verify Email | Zenni Optical", body,
+                             ctx.state(connection())))
+
+
+@app.post("/register/verify")
+def register_verify(request: Request, code: str = Form(...)) -> Response:
+    ctx = Ctx(request)
+    try:
+        AUTH.verify_registration_code(ctx.token, code=code)
+        AUTH.complete_registration(ctx.token)
+    except Exception as error:
+        return redirect(
+            ctx, "/register/verify?" + urlencode({"error": str(error)[:160]}))
+    return redirect(ctx, "/myAccount/myDashBoard")
+
+
+@app.post("/logout")
+def logout(request: Request) -> Response:
+    ctx = Ctx(request)
+    AUTH.sign_out(ctx.token)
+    ctx.new_cookie = True
+    ctx.token, _ = AUTH.ensure_session(None)
+    return redirect(ctx, "/")
+
+
+# --------------------------------------------------------------------------
+# Storefront
+
+
+@app.get("/", response_class=HTMLResponse)
+def home(request: Request) -> Response:
+    ctx = Ctx(request)
+    conn = connection()
+    favourites = store.favorites(conn, ctx.token)
+    # Section order, backgrounds and card geometry follow the measured source
+    # home page: two tinted product rails, category rows of 198x186 artwork,
+    # full-width campaign banners, then the payment and sign-up strips.
+    def rail(slides, name, w, h, per_view=2, autoplay=True):
+        return render.carousel(slides, name=name, card_w=w, card_h=h,
+                               per_view=per_view, autoplay=autoplay)
+
+    def section(heading, inner, testid, *, tint="", links=(), lede="",
+                center=False):
+        head = ""
+        if heading:
+            head_links = ""
+            if links:
+                head_links = '<span class="sec-links">' + "".join(
+                    f'<a href="{escape(href)}">{escape(text)}</a>'
+                    for text, href in links) + "</span>"
+            head = (f'<div class="sec-head"><h2>{escape(heading)}</h2>'
+                    f"{head_links}</div>")
+        classes = " ".join(x for x in ("home-section", tint,
+                                       "center" if center else "") if x)
+        return (
+            f'<section class="{classes}" data-testid="{testid}">'
+            f'<div class="wrap">{head}'
+            + (f'<p class="home-lede">{escape(lede)}</p>' if lede else "")
+            + f"{inner}</div></section>"
+        )
+
+    best_items = catalog.query(
+        where={"category": "eyeglasses"},
+        sort_by="prod_zenni_products_en_best_seller")["items"][:12]
+    under30 = catalog.query(where={"max_price": 30.0},
+                            sort_by="prod_zenni_products_en_top_rated"
+                            )["items"][:12]
+
+    body = (
+        f'<div class="wrap">{render.pill_row(home_content.PILLS)}</div>'
+        f'{rail(home_content.HERO_SLIDES, "hp-hero", 604, 480)}'
+        + section(
+            "Best Sellers",
+            '<div class="rail-tabs" data-testid="hp-bestseller-tabs">'
+            '<a href="/b/all-glasses" aria-current="true">Eyeglasses</a>'
+            '<a href="/b/sunglasses" aria-current="false">Sunglasses</a>'
+            "</div>"
+            + render.rail_grid(best_items, favourites, "hp-bestsellers-grid"),
+            "home-best-sellers", tint="tint-blue",
+            links=[("Shop all", "/b/best-seller-glasses")])
+        + section(
+            "", rail(home_content.BEST_SELLER_RAIL, "hp-promo-rail", 604, 515),
+            "home-promo-rail")
+        + section(
+            "Eyewear for Everyone\u00ae",
+            '<div class="service-row">' + "".join(
+                f'<a href="{escape(href)}">{escape(text)}</a>'
+                for text, href in home_content.SERVICE_LINKS) + "</div>"
+            + '<div class="trust-row">' + "".join(
+                f"<div><strong>{escape(head)}</strong>{escape(sub)}</div>"
+                for head, sub in home_content.TRUST_POINTS) + "</div>"
+            + render.banner(home_content.BANNERS["bogo"], "hp-banner-bogo"),
+            "home-eyewear-for-everyone", center=True)
+        + section(
+            "Smarter Defense Starts Here",
+            rail(home_content.EDUCATIONAL_RAIL, "hp-educational-rail",
+                 604, 480),
+            "home-smarter-defense", center=True)
+        + section(
+            "So Many Ways to See",
+            rail(home_content.WAYS_TO_SEE_RAIL, "hp-ways-rail", 604, 480),
+            "home-ways-to-see", center=True)
+        + section(
+            "Shop by Frame Shape",
+            render.category_row(home_content.FRAME_SHAPES, "hp-frame-shape"),
+            "home-frame-shape", center=True)
+        + f'<div class="wrap">'
+          f'{render.banner(home_content.BANNERS["trend"], "hp-banner-trend")}'
+          f"</div>"
+        + section(
+            "Under $30 Picks",
+            render.rail_grid(under30, favourites, "hp-under30-grid"),
+            "home-under-30", tint="tint-teal",
+            links=[("Shop all", "/b/glasses-under-30")])
+        + section(
+            "Shop by Price",
+            render.mini_pills(home_content.PRICE_TILES, "hp-price-pills"),
+            "home-shop-by-price", center=True)
+        + section(
+            "Shop by Face Shape",
+            render.category_row(home_content.FACE_SHAPES, "hp-face-shape"),
+            "home-face-shape", center=True)
+        + section(
+            "Frames for Your Life",
+            render.category_row(home_content.FRAMES_FOR_LIFE,
+                                "hp-frames-for-life"),
+            "home-frames-for-life", center=True)
+        + section(
+            "",
+            '<div class="csr">' + "".join(
+                render.banner(tile, f"hp-csr-{i}")
+                for i, tile in enumerate(home_content.CSR_TILES)) + "</div>",
+            "home-see-to-succeed")
+        + render.payment_strip(home_content.PAYMENT_METHODS)
+        + render.signup_strip(home_content.SOCIAL)
+    )
+    return respond(ctx, page(
+        "Zenni Optical | Eyewear for Everyone® | Affordable Glasses and "
+        "Sunglasses", body, ctx.state(conn)))
+
+
+def _filter_panel(base_path: str, params: dict[str, str],
+                  selected: dict[str, list[str]]) -> str:
+    groups = []
+    for group in catalog.FACET_GROUPS:
+        key = group["key"]
+        chosen = selected.get(key, [])
+        options = []
+        for value in group["values"]:
+            active = value in chosen
+            rest = {k: list(v) for k, v in selected.items()}
+            values = list(rest.get(key, []))
+            if active:
+                values.remove(value)
+            else:
+                values.append(value)
+            if values:
+                rest[key] = values
+            else:
+                rest.pop(key, None)
+            query = {k: v for k, v in params.items()
+                     if v and k not in {"filter", "page"}}
+            filter_value = catalog.unparse_filters(rest)
+            if filter_value:
+                query["filter"] = filter_value
+            href = base_path + (f"?{urlencode(query)}" if query else "")
+            options.append(
+                f'<li><a data-testid="filter-checkbox-{escape(key)}:'
+                f'{escape(value)}" href="{escape(href)}">'
+                f'<label><input type="checkbox" readonly '
+                f'{"checked" if active else ""}> {escape(value)}</label>'
+                "</a></li>"
+            )
+        helper = ""
+        if key == "prod_lens_width_size":
+            helper = ('<a class="linkbtn" data-testid="find-my-size" '
+                      'href="/measure-eyeglass-frame-size-how-to">'
+                      "Find my size</a>")
+        elif key == "sku_color":
+            helper = ('<a class="linkbtn" data-testid="find-my-pd" '
+                      'href="/measuring-pd-infographic">Find my PD</a>')
+        groups.append(
+            f'<details class="facet" open><summary '
+            f'data-testid="{escape(key)}-accordion">{escape(group["title"])}'
+            f'</summary><ul>{"".join(options)}</ul>{helper}</details>'
+        )
+    cleared = {k: v for k, v in params.items()
+               if v and k not in {"filter", "page"}}
+    clear_href = base_path + (f"?{urlencode(cleared)}" if cleared else "")
+    return (
+        '<aside class="filter-panel">'
+        '<div class="filter-panel-head">'
+        '<h3 data-testid="filter-panel-title">Filters</h3>'
+        '<button class="linkbtn" data-testid="hide-filters" '
+        'aria-expanded="true" aria-controls="filter-groups">Hide Filters'
+        "</button></div>"
+        f'<div id="filter-groups">{"".join(groups)}</div>'
+        '<div class="filter-panel-foot">'
+        f'<a class="linkbtn" data-testid="clear-filters" '
+        f'href="{escape(clear_href)}">Clear</a>'
+        '<a class="zenbtn zenbtn-primary" data-testid="show-results" '
+        'href="#filter-groups">Show results</a></div></aside>'
+    )
+
+
+def _listing_page(ctx: Ctx, request: Request, *, base_path: str, title: str,
+                  meta_title: str, where: dict[str, Any] | None = None,
+                  keyphrase: str | None = None, slug: str | None = None,
+                  lead: str | None = None) -> Response:
+    conn = connection()
+    params = dict(request.query_params)
+    selected = catalog.parse_filters(params.get("filter"))
+    sort_by = params.get("sortBy", "")
+    try:
+        page_no = int(params.get("page", "1"))
+    except ValueError:
+        page_no = 1
+    result = catalog.query(where=where, keyphrase=keyphrase, filters=selected,
+                           sort_by=sort_by, page=page_no)
+    favourites = store.favorites(conn, ctx.token)
+
+    chips = ""
+    if selected:
+        pieces = []
+        for key, values in selected.items():
+            for value in values:
+                rest = {k: list(v) for k, v in selected.items()}
+                rest[key] = [v for v in rest[key] if v != value]
+                if not rest[key]:
+                    rest.pop(key)
+                query = {k: v for k, v in params.items()
+                         if v and k not in {"filter", "page"}}
+                filter_value = catalog.unparse_filters(rest)
+                if filter_value:
+                    query["filter"] = filter_value
+                href = base_path + (f"?{urlencode(query)}" if query else "")
+                pieces.append(
+                    f'<a class="chip" href="{escape(href)}">'
+                    f"{escape(value)} &times;</a>")
+        chips = f'<div class="chips">{"".join(pieces)}</div>'
+
+    if result["items"]:
+        listing = (
+            render.product_grid(
+                result["items"], favourites,
+                offset=(result["page"] - 1) * catalog.PAGE_SIZE)
+            + render.pagination(base_path, params, result["page"],
+                                result["pages"])
+        )
+    else:
+        listing = (
+            '<div class="empty"><h2>No results were found</h2>'
+            "<p>Please try modifying your filters or browse our top "
+            "categories:</p>"
+            '<p><a class="zenbtn zenbtn-primary-outline" href="/b/sunglasses">'
+            "Shop All Sunglasses</a></p></div>"
+        )
+
+    first = (result["page"] - 1) * catalog.PAGE_SIZE + 1 if result["total"] else 0
+    last = min(first + catalog.PAGE_SIZE - 1, result["total"])
+    counter = (f'{first}-{last} of {result["total"]} items'
+               if result["total"] else "0 items")
+
+    head = ""
+    if slug:
+        art = catalog.banner(slug)
+        head += (
+            f'<div class="plp-banner">'
+            f'<div class="kicker">{escape(art["kicker"])}</div>'
+            f'<h2>{escape(art["headline"])}</h2>'
+            f'<p>{escape(art["sub"])}</p></div>'
+        )
+    head += f'<h1 class="page">{escape(title)}</h1>'
+    if lead:
+        head += f'<p class="plp-seo">{escape(lead)}</p>'
+    related = catalog.related_links(slug or "")
+    if related:
+        head += '<div class="plp-related">' + "".join(
+            f'<a href="{escape(href)}">{escape(text)}</a>'
+            for text, href in related) + "</div>"
+
+    crumb = (
+        '<nav class="breadcrumb" aria-label="Breadcrumb">'
+        '<a href="/" aria-label="Home">&#8962;</a><span>&rsaquo;</span>'
+        f'<span>{escape(title)}</span></nav>'
+    )
+    density = (
+        '<div class="density" role="group" aria-label="Grid density">'
+        '<span class="g2"><i></i><i></i><i></i><i></i></span>'
+        '<span class="g3" aria-current="true">'
+        '<i></i><i></i><i></i><i></i><i></i><i></i></span></div>'
+    )
+    body = (
+        f'<div class="wrap">{crumb}'
+        f'<div class="plp">{_filter_panel(base_path, params, selected)}'
+        f'<section>{head}<div class="plp-toolbar">'
+        f'<span data-testid="results-counter">{counter}</span>'
+        f'<span style="display:flex;gap:20px;align-items:center">{density}'
+        f'{render.sort_control(base_path, params, sort_by)}</span></div>'
+        f"{chips}{listing}</section></div></div>"
+    )
+    return respond(ctx, page(meta_title, body, ctx.state(conn)))
+
+
+@app.get("/b/{slug:path}", response_class=HTMLResponse)
+def category_page(slug: str, request: Request) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    entry = catalog.category(slug)
+    if entry is None:
+        return not_found(ctx)
+    meta = entry.get("meta_title") or entry["title"]
+    if entry.get("kind") == "accessories":
+        return _accessory_listing(ctx, entry["title"], meta)
+    return _listing_page(
+        ctx, request, base_path=f"/b/{slug}", title=entry["title"],
+        meta_title=f"{meta} | Zenni Optical", where=entry.get("where"),
+        slug=slug, lead=entry.get("lead"))
+
+
+def _accessory_listing(ctx: Ctx, title: str, meta_title: str) -> Response:
+    """Accessories list without the frame facets the source also omits."""
+
+    cards = "".join(
+        render.accessory_card(item, "/b/accessories")
+        for item in accessories.accessories()
+    )
+    body = (
+        f'<div class="wrap"><h1 class="page">{escape(title)}</h1>'
+        f'<p class="muted">{len(accessories.accessories())} accessories</p>'
+        f'<div class="accessories">{cards}</div></div>'
+    )
+    return respond(ctx, page(f"{meta_title} | Zenni Optical", body,
+                             ctx.state(connection())))
+
+
+@app.get("/search", response_class=HTMLResponse)
+def search(request: Request, keyphrase: str = "") -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    conn = connection()
+    needle = keyphrase.strip()
+    target = catalog.SEARCH_REDIRECTS.get(needle.lower())
+    if target:
+        return redirect(ctx, f"/b/{target}", status=302)
+    result = catalog.query(keyphrase=needle) if needle else {
+        "items": [], "total": 0, "page": 1, "pages": 1}
+    if not result["items"]:
+        links = "".join(
+            f'<li><a href="{escape(href)}">{escape(text)}</a></li>'
+            for text, href in [
+                ("Shop All", "/b/all-glasses"),
+                ("Shop by Women", "/b/all-women-glasses"),
+                ("Shop by Men", "/b/all-men-glasses"),
+                ("Shop by Best Sellers", "/b/best-seller-glasses"),
+                ("Shop by Sunglasses", "/b/sunglasses"),
+                ("Shop by Under $30", "/b/glasses-under-30"),
+            ]
+        )
+        suggestions = catalog.query(sort_by="rating_desc")["items"][:6]
+        body = (
+            '<div class="wrap"><div class="empty">'
+            f"<h2>No results were found for “{escape(needle)}”</h2>"
+            "<p>Please try modifying your search term or feel free to browse "
+            "our top categories:</p>"
+            f'<ul style="list-style:none;padding:0">{links}</ul></div>'
+            '<h2 class="sec">You Might Also Like</h2>'
+            f'{render.product_grid(suggestions, store.favorites(conn, ctx.token))}'
+            "</div>"
+        )
+        return respond(ctx, page("Search Result | Zenni Optical", body,
+                                 ctx.state(conn)))
+    return _listing_page(
+        ctx, request, base_path="/search",
+        title=f"Search Results for “{needle}”",
+        meta_title="Search Result | Zenni Optical", keyphrase=needle)
+
+
+@app.get("/p/{slug}/{product_id}/{sku}", response_class=HTMLResponse)
+def product_detail(slug: str, product_id: str, sku: str,
+                   request: Request, tab: str = "description") -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    conn = connection()
+    found = catalog.find_sku(sku)
+    if not found or found[0]["product_id"] != product_id:
+        return not_found(ctx)
+    product, variant = found
+    kind = "Sunglasses" if product["category"] == "sunglasses" else "Glasses"
+    heading = f'{variant["color"]} {product["shape"]} {kind} #{sku}'
+    images = variant["images"]
+    order = [v for v in ("front", "side", "angle") if v in images]
+    hero = images[order[0]]
+    thumbs = "".join(
+        f'<button data-testid="{escape(view.title())} view of {kind} {sku} '
+        f'in {escape(variant["color"] or "")} thumbnail" '
+        f'aria-current="{"true" if index == 0 else "false"}">'
+        f'<img src="{escape(images[view])}" alt="{escape(view)} view">'
+        "</button>"
+        for index, view in enumerate(order)
+    )
+    swatches = "".join(
+        f'<a class="style_option{" style_active" if v["sku"] == sku else ""}" '
+        f'data-testid="color-option-{v["sku"]}" '
+        f'aria-label="Select {escape(v["color"] or "")} color" '
+        f'href="/p/{product["slug"]}/{product_id}/{v["sku"]}">'
+        f'{render.swatch(v["color"])}</a>'
+        for v in product["variants"]
+    )
+    tabs = "".join(
+        f'<a data-testid="tab-{key}" aria-current="{"true" if tab == key else "false"}" '
+        f'href="/p/{slug}/{product_id}/{sku}?tab={key}">{escape(label)}</a>'
+        for key, label in [("fitSize", "Fit & Size"),
+                           ("features", "Features"),
+                           ("description", "Description")]
+    )
+    if tab == "fitSize":
+        panel = (
+            f'<p>Frame width {product["frame_width"]}mm, lens height '
+            f'{product["frame_height"]}mm, weight {product["weight"]}g. '
+            f'Size {variant["size"]}.</p>'
+        )
+    elif tab == "features":
+        panel = (
+            "<ul><li>High-quality frame</li>"
+            "<li>Optimized premium lens</li><li>Anti-scratch coating</li>"
+            "<li>100% UV protection</li></ul>"
+        )
+    else:
+        panel = f'<p>{escape(product["description"] or "")}</p>'
+    faved = sku in store.favorites(conn, ctx.token)
+    here = f"/p/{slug}/{product_id}/{sku}"
+    addons = "".join(
+        render.accessory_card(item, here)
+        for item in accessories.suggestions(product_id)
+    )
+    review_panel = render.review_block(
+        product,
+        reviews.reviews(sku, product["rating"] or 0,
+                        product["review_count"] or 0),
+        reviews.snapshot(product["rating"] or 0, product["review_count"] or 0),
+        reviews.averages(sku),
+    )
+    rating = ""
+    if product["rating"]:
+        # The source rounds the group rating to one decimal in this pill.
+        rating = (
+            f'<span class="rating-pill" data-testid="pdp-rating">'
+            f'<span aria-hidden="true">&#9733;</span>'
+            f'<strong>{product["rating"]:.1f}</strong>'
+            f'<a href="#pdp-reviews">{product["review_count"]} reviews</a>'
+            "</span>"
+        )
+    crumb = (
+        '<nav class="breadcrumb" aria-label="Breadcrumb">'
+        '<a href="/" aria-label="Home">&#8962;</a><span>&rsaquo;</span>'
+        f'<span>{escape(product["shape"])} '
+        f'{"Sunglasses" if product["category"] == "sunglasses" else "Glasses"} '
+        f'{sku}</span></nav>'
+    )
+    body = (
+        f'<div class="wrap">{crumb}<div class="pdp"><div class="pdp-media">'
+        f'<div class="pdp-stage">'
+        f'<form method="post" action="/favorites/toggle" class="pdp-fav">'
+        f'<input type="hidden" name="sku" value="{sku}">'
+        f'<input type="hidden" name="next" value="{escape(here)}">'
+        f'<button class="favorite-btn" data-testid="add-favorite-sku-{sku}" '
+        f'aria-pressed="{"true" if faved else "false"}" '
+        f'title="Add To My Favorite">{"&#9829;" if faved else "&#9825;"}'
+        f"</button></form>"
+        f'<button class="media-arrow left" '
+        f'data-testid="product-media-left-arrow" aria-label="Previous image">'
+        f"&lsaquo;</button>"
+        f'<div class="pdp-hero"><img src="{escape(hero)}" '
+        f'alt="{escape(heading)}"></div>'
+        f'<button class="media-arrow right" '
+        f'data-testid="product-media-right-arrow" aria-label="Next image">'
+        f"&rsaquo;</button></div>"
+        f'<div class="media-actions">'
+        f'<span class="round-btn" data-testid="product-360-degree-btn">'
+        f"360&deg;</span>"
+        f'<a class="zenbtn zenbtn-primary-outline" '
+        f'data-testid="vto-fitting-box-btn" href="/tryon?sku={sku}">Try On</a>'
+        f'<span class="round-btn" '
+        f'data-testid="product-ruler-front-measure-btn">&#8596;</span></div>'
+        f'<div class="pdp-thumbs">{thumbs}</div></div>'
+        f"<div><h1>{escape(heading)}</h1>"
+        f'<div class="price-row"><div>'
+        f'<p class="muted" style="margin:0">Starting at</p>'
+        f'<p class="pdp-price" style="margin:0">'
+        f'{money(float(variant["price"]))}</p></div>{rating}</div>'
+        f'<div class="pdp-card">'
+        f'<div class="row"><div><strong>Size:</strong> '
+        f'{variant["lens_width"]}mm frame width &middot; '
+        f'{variant["lens_height"]}mm lens height</div>'
+        f'<a class="linkbtn" data-testid="size-chart-link" '
+        f'href="/measure-eyeglass-frame-size-how-to">Size and fit</a></div>'
+        f'<span class="size-chip" data-testid="size-frame-type-tag">'
+        f'{escape(variant["size"] or "")}</span>'
+        f'<div style="margin-top:16px"><strong>Frame Color:</strong> '
+        f'<span data-testid="pdp-product-color">'
+        f'{escape(variant["color"] or "")}</span></div>'
+        f'<div class="swatch-row" style="margin-top:10px">{swatches}</div>'
+        f"</div>"
+        f'<p class="pdp-note muted">Shown with smoke gray gradient tint. '
+        f"(Additional charges apply)</p>"
+        f'<div class="rush-row" data-testid="rush-delivery">'
+        f'<span class="rush-pill">Rush Delivery</span>'
+        f'<label><input type="checkbox" name="rush" value="1"> '
+        f'<strong>{render.DELIVERY_ETA}</strong></label>'
+        f'<span class="muted">Rush Delivery starts at $19 '
+        f'<a class="linkbtn" href="/help/shipping-returns/shipping-delivery">'
+        f"See restrictions</a></span></div>"
+        f'<a class="zenbtn zenbtn-primary zenbtn-cta" '
+        f'data-testid="btn-pdp-enter-prescription" '
+        f'href="/orderProcess?productId={product_id}&skuId={sku}">'
+        f'Select Lens &amp; Tint</a>'
+        f'<div class="pdp-card"><div>Pay over time with PayPal, Affirm or '
+        f'Afterpay <a class="linkbtn" href="/c/faq">Learn More</a></div>'
+        f'<div style="margin-top:8px">Use your insurance or FSA/HSA benefits. '
+        f'<a class="linkbtn" href="/c/faq">Learn more</a></div></div>'
+        f"</div></div>"
+        f'<div class="tabs">{tabs}</div>'
+        f'<div class="tabpanel" role="tabpanel">{panel}</div>'
+        f'<div class="spec-grid">'
+        f'<div><dt>Material</dt><dd>{escape(product["material"] or "")}</dd></div>'
+        f'<div><dt>Shape</dt><dd>{escape(product["shape"])}</dd></div>'
+        f'<div><dt>Rim</dt><dd>{escape(product["rim"])}</dd></div>'
+        f'<div><dt>Gender</dt><dd>{escape(product["gender"])}</dd></div>'
+        f"</div>"
+        f'<h2 class="sec">Customers also bought</h2>'
+        f'<div class="accessories">{addons}</div>'
+        f'<h2 class="sec">You Might Also Like</h2>'
+        f'{render.product_grid(_related(product), store.favorites(conn, ctx.token))}'
+        f"{review_panel}</div>"
+    )
+    return respond(ctx, page(f"{heading} | Zenni Optical", body,
+                             ctx.state(conn)))
+
+
+def _related(product: dict[str, Any]) -> list[dict[str, Any]]:
+    same = [
+        other for other in catalog.products()
+        if other["product_id"] != product["product_id"]
+        and other["shape"] == product["shape"]
+    ]
+    if len(same) < 6:
+        same += [
+            other for other in catalog.products()
+            if other["product_id"] != product["product_id"] and other not in same
+        ]
+    return same[:6]
+
+
+@app.get("/tryon", response_class=HTMLResponse)
+def tryon(request: Request, sku: str = "") -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    found = catalog.find_sku(sku) if sku else None
+    if not found:
+        return not_found(ctx)
+    product, variant = found
+    body = (
+        '<div class="wrap"><h1 class="page">Virtual Try-On</h1>'
+        '<div class="card"><p>This offline clone renders the frame preview '
+        "from the local product images instead of a camera capture. No photo "
+        "is requested, uploaded or stored.</p>"
+        f'<img style="max-width:520px" src="{escape(variant["images"].get("front", ""))}" '
+        f'alt="{escape(variant["color"] or "")} frame preview">'
+        f'<p><a class="zenbtn zenbtn-primary" '
+        f'href="/p/{product["slug"]}/{product["product_id"]}/{sku}">'
+        "Back to frame</a></p></div></div>"
+    )
+    return respond(ctx, page("Virtual Try-On | Zenni Optical", body,
+                             ctx.state(connection())))
+
+
+# --------------------------------------------------------------------------
+# Lens configurator
+
+
+def _wizard_config(params: dict[str, str]) -> dict[str, str]:
+    return {
+        key: params[key] for key in
+        ("usage", "lens_type", "tint", "lens_index", "coating", "engraving",
+         "warranty")
+        if params.get(key)
+    }
+
+
+@app.get("/orderProcess", response_class=HTMLResponse)
+def order_process(request: Request, productId: str = "", skuId: str = "",
+                  screen: str = "prescription-type") -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    found = catalog.find_sku(skuId)
+    if not found or found[0]["product_id"] != productId:
+        return not_found(ctx)
+    product, variant = found
+    params = dict(request.query_params)
+    config = _wizard_config(params)
+    if screen not in lenses.SCREENS or not lenses.screen_applies(screen, config):
+        screen = "prescription-type"
+    running = lenses.price(float(variant["price"]), config)
+
+    steps = "".join(
+        f'<li aria-current="{"step" if screen in screens else "false"}">'
+        f"{escape(label)}</li>"
+        for label, screens in lenses.STEP_LABELS
+    )
+
+    def keep(extra: dict[str, str]) -> str:
+        query = {"productId": productId, "skuId": skuId}
+        query.update(config)
+        query.update(extra)
+        return "?" + urlencode({k: v for k, v in query.items() if v})
+
+    heading, blurb, cards, primary = _wizard_screen(
+        screen, config, keep, productId, skuId)
+
+    previous = lenses.previous_screen(screen, config)
+    back = (
+        f'<a class="linkbtn" href="/orderProcess{keep({"screen": previous})}">'
+        "Previous Step</a>" if previous else
+        f'<a class="linkbtn" href="/p/{product["slug"]}/{productId}/{skuId}">'
+        "Back to Frame</a>"
+    )
+    summary_rows = "".join(
+        f'<div class="pdp-row"><span class="muted">{escape(label)}</span><br>'
+        f"{escape(value)}</div>"
+        for label, value in lenses.describe(config)
+    )
+    body = (
+        f'<div class="wrap"><div class="wizard"><section>'
+        f"<p>{back}</p>"
+        f'<ul class="steps">{steps}</ul>'
+        f'<h1 class="page">{escape(heading)}</h1>'
+        f'<p class="muted">{escape(blurb)}</p>'
+        f'<div class="cards">{cards}</div>{primary}</section>'
+        f'<aside class="summary-card">'
+        f'<img src="{escape(variant["images"].get("front", ""))}" '
+        f'alt="{escape(variant["color"] or "")} frame">'
+        f'<strong>{escape(product["shape"])} '
+        f'{"Sunglasses" if product["category"] == "sunglasses" else "Glasses"}'
+        f'</strong><span class="muted">{escape(variant["color"] or "")} '
+        f'&middot; {escape(variant["size"] or "")} &middot; {skuId}</span>'
+        f'<div class="pdp-row"><span class="muted">Price</span><br>'
+        f'<span class="pdp-price" data-testid="running-price">'
+        f"{money(running)}</span></div>{summary_rows}"
+        '<p class="muted">Shipping &amp; handling calculated at checkout</p>'
+        "</aside></div></div>"
+    )
+    return respond(ctx, page("Order Page | Zenni Optical", body,
+                             ctx.state(connection())))
+
+
+def _wizard_screen(screen: str, config: dict[str, str], keep,
+                   product_id: str, sku: str) -> tuple[str, str, str, str]:
+    field = lenses.FIELD_FOR_SCREEN.get(screen)
+    headings = {
+        "prescription-type": ("How will you use your glasses?", ""),
+        "prescription": ("Enter your prescription",
+                         "Values stay in this local database."),
+        "lens-type": ("What type of lens do you need ?", ""),
+        "sunglasses-lens-type": (
+            "Choose a Sunglass tint",
+            "All styles feature a fixed, all-day tint that stays dark indoors "
+            "and out."),
+        "lens-index": ("Select a lens index", ""),
+        "lens-coating": (
+            "Add a protective coating to your lenses",
+            "All our lenses meet the US standard for 100% UV protection "
+            "according to ANSI Z80.1, and come with scratch-resistant "
+            "coatings."),
+        "addon": ("Add Ons (optional)", "Complete your look with a engraving"),
+        "warranty": ("Protect your purchase (optional)",
+                     "Add our extended warranty to protect your glasses for a "
+                     "full year."),
+    }
+    heading, blurb = headings[screen]
+
+    if screen == "prescription":
+        following = lenses.next_screen(screen, config)
+        hidden = "".join(
+            f'<input type="hidden" name="{k}" value="{escape(v)}">'
+            for k, v in config.items())
+        cards = (
+            '<form method="get" action="/orderProcess" class="grid">'
+            f'<input type="hidden" name="productId" value="{product_id}">'
+            f'<input type="hidden" name="skuId" value="{sku}">'
+            f'<input type="hidden" name="screen" value="{following}">'
+            f"{hidden}"
+            '<label>OD (right) sphere<input name="od" value="-1.00"></label>'
+            '<label>OS (left) sphere<input name="os" value="-1.25"></label>'
+            '<label>Pupillary distance (PD)<input name="pd" value="63">'
+            "</label>"
+            '<div class="full"><button class="zenbtn zenbtn-primary '
+            'zenbtn-large" data-testid="button-primary-screen-prescription">'
+            "Continue</button></div></form>"
+        )
+        return heading, blurb, cards, ""
+
+    if screen == "addon":
+        following = lenses.next_screen(screen, config)
+        hidden = "".join(
+            f'<input type="hidden" name="{k}" value="{escape(v)}">'
+            for k, v in config.items() if k != "engraving")
+        cards = (
+            '<form method="get" action="/orderProcess">'
+            f'<input type="hidden" name="productId" value="{product_id}">'
+            f'<input type="hidden" name="skuId" value="{sku}">'
+            f'<input type="hidden" name="screen" value="{following}">'
+            f"{hidden}"
+            '<div class="productCardContainer" data-testid="engraving">'
+            f'<span class="heading">Engraving</span> '
+            f'<span class="muted">(From +{money(lenses.ENGRAVING_PRICE)})</span>'
+            "<p>Add a personal touch with your name, a special message or a "
+            "symbol to make your glasses unique.</p>"
+            '<label>Engraving text<input name="engraving" maxlength="20" '
+            f'value="{escape(config.get("engraving", ""))}"></label></div>'
+            '<p><button class="zenbtn zenbtn-primary zenbtn-large" '
+            'data-testid="button-primary-screen-addon">Continue</button></p>'
+            "</form>"
+        )
+        return heading, blurb, cards, ""
+
+    if screen == "warranty":
+        hidden = "".join(
+            f'<input type="hidden" name="{k}" value="{escape(v)}">'
+            for k, v in config.items())
+        cards = (
+            f'<a class="productCardContainer" '
+            f'href="/orderProcess{keep({"screen": "warranty", "warranty": "1"})}" '
+            f'aria-pressed="{"true" if config.get("warranty") else "false"}">'
+            f'<span class="heading">1-Year Extended Warranty</span> '
+            f'<span class="muted">+{money(lenses.WARRANTY_PRICE)}</span>'
+            "<p>Covers breaks, scratches, and daily wear for a full year, "
+            "with one replacement pair included.</p></a>"
+        )
+        primary = (
+            '<form method="post" action="/cart/add">'
+            f'<input type="hidden" name="sku" value="{sku}">'
+            f"{hidden}"
+            '<button class="zenbtn zenbtn-primary zenbtn-large" '
+            'data-testid="button-primary-screen-warranty">Add to cart</button>'
+            "</form>"
+        )
+        return heading, blurb, cards, primary
+
+    following = lenses.next_screen(screen, config)
+    prefix = {
+        "lens-index": "lens-index-card-",
+        "lens-coating": "lens-coating-card-",
+    }.get(screen, "")
+
+    def option_card(option: dict[str, Any]) -> str:
+        chips = "".join(
+            f'<span class="muted">{escape(option[key])}</span><br>'
+            for key in ("tag", "flag") if option.get(key)
+        )
+        extra = (
+            f' <span class="muted">+{money(option["price"])}</span>'
+            if option["price"] else ""
+        )
+        pressed = "true" if config.get(field) == option["id"] else "false"
+        href = keep({field: option["id"], "screen": screen})
+        return (
+            f'<a class="productCardContainer" '
+            f'data-testid="{prefix}{option["id"]}" aria-pressed="{pressed}" '
+            f'href="/orderProcess{href}">{chips}'
+            f'<span class="heading" data-testid="heading-{option["id"]}">'
+            f'{escape(option["heading"])}</span>{extra}'
+            f'<p>{escape(option["body"])}</p></a>'
+        )
+
+    cards = "".join(option_card(o) for o in lenses.options_for(screen))
+    disabled = "" if config.get(field) else " disabled"
+    primary = (
+        f'<a class="zenbtn zenbtn-primary zenbtn-large" '
+        f'data-testid="button-primary-screen-{screen}" '
+        f'href="/orderProcess{keep({"screen": following})}"{disabled}>'
+        "Continue</a>"
+        if config.get(field) else
+        f'<span class="zenbtn zenbtn-primary zenbtn-large" '
+        f'data-testid="button-primary-screen-{screen}" aria-disabled="true">'
+        "Continue</span>"
+    )
+    return heading, blurb, cards, primary
+
+
+# --------------------------------------------------------------------------
+# Cart, checkout and favourites
+
+
+@app.post("/cart/add")
+def cart_add(request: Request, sku: str = Form(...), usage: str = Form(""),
+             lens_type: str = Form(""), tint: str = Form(""),
+             lens_index: str = Form(""), coating: str = Form(""),
+             engraving: str = Form(""), warranty: str = Form("")) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    found = catalog.find_sku(sku)
+    if not found:
+        return not_found(ctx)
+    _, variant = found
+    config = {"usage": usage, "lens_type": lens_type, "tint": tint,
+              "lens_index": lens_index, "coating": coating,
+              "engraving": engraving, "warranty": bool(warranty)}
+    unit = lenses.price(float(variant["price"]), {
+        k: v for k, v in config.items() if v})
+    store.add_to_cart(connection(), ctx.token, ctx.subject_id, sku, config,
+                      unit)
+    return redirect(ctx, "/shoppingCart")
+
+
+@app.post("/cart/add-accessory")
+def cart_add_accessory(request: Request, sku: str = Form(...),
+                       next: str = Form("/shoppingCart")) -> Response:
+    """Accessories skip the lens builder, exactly as they do on the source."""
+
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    item = accessories.find(sku)
+    if not item:
+        return not_found(ctx)
+    store.add_to_cart(
+        connection(), ctx.token, ctx.subject_id, sku,
+        {"usage": "accessory", "lens_type": "", "tint": None,
+         "lens_index": "", "coating": "", "engraving": "", "warranty": False},
+        float(item["price"]))
+    return redirect(ctx, next or "/shoppingCart")
+
+
+@app.post("/cart/update")
+def cart_update(request: Request, item_id: int = Form(...),
+                quantity: int = Form(...)) -> Response:
+    ctx = Ctx(request)
+    store.set_quantity(connection(), ctx.token, item_id, quantity)
+    return redirect(ctx, "/shoppingCart")
+
+
+@app.post("/cart/remove")
+def cart_remove(request: Request, item_id: int = Form(...)) -> Response:
+    ctx = Ctx(request)
+    store.remove_item(connection(), ctx.token, item_id)
+    return redirect(ctx, "/shoppingCart")
+
+
+@app.get("/shoppingCart", response_class=HTMLResponse)
+def shopping_cart(request: Request) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    conn = connection()
+    items = store.cart_items(conn, ctx.token)
+    if not items:
+        body = (
+            '<div class="wrap"><h1 class="page">Shopping Cart</h1>'
+            '<div class="empty"><h2>Your shopping cart is empty.</h2>'
+            "<p>You have no items in your shopping cart.</p>"
+            '<p><a class="zenbtn zenbtn-primary zenbtn-large" '
+            'href="/b/sunglasses">Start shopping</a></p></div></div>'
+        )
+        return respond(ctx, page("Shopping Cart | Zenni Optical", body,
+                                 ctx.state(conn)))
+
+    rows = []
+    for item in items:
+        if item["kind"] == "accessory":
+            rows.append(_accessory_cart_row(item))
+            continue
+        product, variant = item["product"], item["variant"]
+        config_rows = "".join(
+            f'<div class="muted">{escape(label)}: {escape(value)}</div>'
+            for label, value in lenses.describe(
+                {k: v for k, v in item["config"].items() if v})
+        )
+        rows.append(
+            f'<article class="cart-item" data-testid="cart-item-{item["id"]}">'
+            f'<img src="{escape(variant["images"].get("front", ""))}" '
+            f'alt="{escape(variant["color"] or "")} frame">'
+            f"<div><strong data-testid=\"cart-item-product-name\">"
+            f'{escape(variant["color"] or "")} {escape(product["shape"])} '
+            f'{"Sunglasses" if product["category"] == "sunglasses" else "Glasses"} '
+            f'{item["sku"]}</strong>{config_rows}'
+            f'<div class="cart-item-actions" data-testid="cart-item-actions" '
+            f'style="margin-top:10px;display:flex;gap:14px;align-items:center">'
+            f'<form method="post" action="/cart/update" class="qty">'
+            f'<input type="hidden" name="item_id" value="{item["id"]}">'
+            f'<button name="quantity" value="{item["quantity"] - 1}" '
+            f'data-testid="quantity-minus" aria-label="Decrease quantity">'
+            f"&minus;</button>"
+            f'<span>{item["quantity"]}</span>'
+            f'<button name="quantity" value="{item["quantity"] + 1}" '
+            f'data-testid="quantity-plus" aria-label="Increase quantity">'
+            f"+</button></form>"
+            f'<a class="linkbtn" data-testid="cart-item-edit-button" '
+            f'href="/orderProcess?productId={product["product_id"]}'
+            f'&skuId={item["sku"]}">Edit</a>'
+            f'<form method="post" action="/cart/remove">'
+            f'<input type="hidden" name="item_id" value="{item["id"]}">'
+            f'<button class="linkbtn" data-testid="cart-item-remove-button">'
+            f"Remove</button></form></div></div>"
+            f'<div style="text-align:right"><strong>'
+            f'{money(item["line_total"])}</strong></div></article>'
+        )
+
+    subtotal = round(sum(item["line_total"] for item in items), 2)
+    shipping = 0.0 if subtotal >= 65 else 4.95
+    in_cart = {item["sku"] for item in items}
+    upsell = "".join(
+        render.accessory_card(entry, "/shoppingCart")
+        for entry in accessories.suggestions(items[0]["sku"], count=3)
+        if entry["sku"] not in in_cart
+    )
+    body = (
+        f'<div class="wrap"><h1 class="page">Shopping Cart</h1>'
+        f'<div class="cart"><section>{"".join(rows)}</section>'
+        f'<aside class="summary-card"><h2 style="margin:0">Order Summary</h2>'
+        f'<div class="pdp-row">Subtotal<strong style="float:right">'
+        f"{money(subtotal)}</strong></div>"
+        f'<div class="pdp-row">Shipping<strong style="float:right">'
+        f'{"Free" if shipping == 0 else money(shipping)}</strong></div>'
+        f'<p class="muted">Free standard shipping on orders $65+</p>'
+        f'<a class="zenbtn zenbtn-primary zenbtn-large" '
+        f'data-testid="checkout-button" href="/orderCheckout">Checkout</a>'
+        f"</aside></div>"
+        f'<h2 class="sec">Add an accessory</h2>'
+        f'<div class="accessories">{upsell}</div></div>'
+    )
+    return respond(ctx, page("Shopping Cart | Zenni Optical", body,
+                             ctx.state(conn)))
+
+
+def _accessory_cart_row(item: dict[str, Any]) -> str:
+    """Accessory lines carry no lens configuration, so they show no Edit link."""
+
+    accessory = item["accessory"]
+    return (
+        f'<article class="cart-item" data-testid="cart-item-{item["id"]}">'
+        f'<img src="{escape(accessory["image"])}" '
+        f'alt="{escape(accessory["name"])}">'
+        f'<div><strong data-testid="cart-item-product-name">'
+        f'{escape(accessory["name"])} {item["sku"]}</strong>'
+        f'<div class="muted">Accessory</div>'
+        f'<div class="cart-item-actions" data-testid="cart-item-actions" '
+        f'style="margin-top:10px;display:flex;gap:14px;align-items:center">'
+        f'<form method="post" action="/cart/update" class="qty">'
+        f'<input type="hidden" name="item_id" value="{item["id"]}">'
+        f'<button name="quantity" value="{item["quantity"] - 1}" '
+        f'data-testid="quantity-minus" aria-label="Decrease quantity">'
+        f"&minus;</button><span>{item['quantity']}</span>"
+        f'<button name="quantity" value="{item["quantity"] + 1}" '
+        f'data-testid="quantity-plus" aria-label="Increase quantity">+</button>'
+        f"</form>"
+        f'<form method="post" action="/cart/remove">'
+        f'<input type="hidden" name="item_id" value="{item["id"]}">'
+        f'<button class="linkbtn" data-testid="cart-item-remove-button">'
+        f"Remove</button></form></div></div>"
+        f'<div style="text-align:right"><strong>'
+        f'{money(item["line_total"])}</strong></div></article>'
+    )
+
+
+@app.post("/favorites/toggle")
+def favorites_toggle(request: Request, sku: str = Form(...),
+                     next: str = Form("/")) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    store.toggle_favorite(connection(), ctx.token, ctx.subject_id, sku)
+    return redirect(ctx, next or "/")
+
+
+@app.get("/anonymousFavorites", response_class=HTMLResponse)
+def anonymous_favorites(request: Request) -> Response:
+    ctx = Ctx(request)
+    if ctx.account:
+        return redirect(ctx, "/myAccount/myFavorites")
+    body = (
+        '<div class="wrap"><h1 class="page">Favorites</h1>'
+        '<div class="empty"><h2>No Saved Favorites</h2>'
+        "<p>Sign in to save items you love and access them here anytime.</p>"
+        '<p><a class="zenbtn zenbtn-primary zenbtn-large" href="/login">'
+        "Sign in</a></p></div></div>"
+    )
+    return respond(ctx, page("Favorites | Zenni Optical", body,
+                             ctx.state(connection())))
+
+
+US_STATES = ["CA", "NY", "TX", "WA", "IL", "FL", "MA", "CO", "OR", "NV"]
+
+
+@app.get("/orderCheckout", response_class=HTMLResponse)
+def checkout(request: Request, error: str = "") -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    conn = connection()
+    items = store.cart_items(conn, ctx.token)
+    if not items:
+        return redirect(ctx, "/shoppingCart")
+    subtotal = round(sum(item["line_total"] for item in items), 2)
+    shipping = 0.0 if subtotal >= 65 else 4.95
+    tax = round(subtotal * 0.0725, 2)
+    scenarios = "".join(
+        f'<option value="{escape(entry["id"])}">{escape(entry["display_label"])}'
+        "</option>"
+        for entry in BACKEND.payments.runtime.payments["local_sandbox"]["scenarios"]
+    )
+    states = "".join(f"<option>{code}</option>" for code in US_STATES)
+    banner = f'<p class="flash error">{escape(error)}</p>' if error else ""
+    body = (
+        f'<div class="wrap"><h1 class="page">Checkout</h1>{banner}'
+        f'<div class="cart"><form method="post" action="/orderCheckout">'
+        f"<fieldset><legend>Shipping</legend>"
+        f'<div class="grid" style="display:grid;grid-template-columns:1fr 1fr;'
+        f'gap:16px">'
+        f'<label>Firstname<input name="firstName" required></label>'
+        f'<label>Lastname<input name="lastName" required></label>'
+        f'<label style="grid-column:1/-1">Address'
+        f'<input name="address1" required></label>'
+        f'<label>City<input name="city" required></label>'
+        f'<label>State/Province<select name="stateDropdown">{states}</select>'
+        f"</label>"
+        f'<label>Zip code<input name="postalCode" required></label>'
+        f'<label>Phone<input name="phoneNumber" type="tel"></label>'
+        f"</div></fieldset>"
+        f"<fieldset><legend>Payment</legend>"
+        f'<p class="sandbox">This clone uses the local sandbox payment '
+        f"adapter. No card number is requested, transmitted or stored.</p>"
+        f'<label>Sandbox scenario<select name="scenario">{scenarios}</select>'
+        f"</label></fieldset>"
+        f'<button class="zenbtn zenbtn-primary zenbtn-large" '
+        f'data-testid="place-order">Place order</button></form>'
+        f'<aside class="summary-card"><h2 style="margin:0">Order Summary</h2>'
+        f'<div class="pdp-row">Subtotal<strong style="float:right">'
+        f"{money(subtotal)}</strong></div>"
+        f'<div class="pdp-row">Shipping<strong style="float:right">'
+        f'{"Free" if shipping == 0 else money(shipping)}</strong></div>'
+        f'<div class="pdp-row">Estimated tax<strong style="float:right">'
+        f"{money(tax)}</strong></div>"
+        f'<div class="pdp-row"><strong>Order total</strong>'
+        f'<strong style="float:right">{money(subtotal + shipping + tax)}'
+        f"</strong></div></aside></div></div>"
+    )
+    return respond(ctx, page("Checkout | Zenni Optical", body,
+                             ctx.state(conn)))
+
+
+@app.post("/orderCheckout")
+def checkout_submit(request: Request, firstName: str = Form(...),
+                    lastName: str = Form(...), address1: str = Form(...),
+                    city: str = Form(...), stateDropdown: str = Form(...),
+                    postalCode: str = Form(...), phoneNumber: str = Form(""),
+                    scenario: str = Form("sandbox-approved")) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    conn = connection()
+    items = store.cart_items(conn, ctx.token)
+    if not items:
+        return redirect(ctx, "/shoppingCart")
+    total = round(sum(item["line_total"] for item in items), 2)
+    owner = f"shopper:{ctx.subject_id or ctx.token}"[:240]
+    amount_minor = int(round(total * 100))
+    # Cart row ids are unique per add, so a genuinely new cart yields a new
+    # fingerprint while a resubmitted form replays the same one.
+    basis = "|".join(
+        [owner, str(amount_minor), scenario]
+        + [f'{item["id"]}:{item["sku"]}x{item["quantity"]}' for item in items]
+    )
+    fingerprint = hashlib.sha256(basis.encode("utf-8")).hexdigest()
+    key = f"checkout.{fingerprint[:32]}"
+    try:
+        intent = BACKEND.payments.create_intent(
+            owner=owner, amount_minor=amount_minor, currency="USD",
+            fingerprint=fingerprint, idempotency_key=f"intent.{key}")
+        outcome = BACKEND.payments.attempt(
+            flow_id=intent["flow_id"], owner=owner,
+            amount_minor=amount_minor, currency="USD",
+            fingerprint=fingerprint, scenario_id=scenario,
+            idempotency_key=f"attempt.{key}")
+        approved = outcome.get("status") == "APPROVED"
+    except PaymentRejected:
+        approved = False
+    if not approved:
+        return redirect(
+            ctx,
+            "/orderCheckout?" + urlencode(
+                {"error": "Sandbox payment was declined. "
+                          "Choose another scenario to continue."}),
+        )
+    # Consume the approval inside the same transaction that writes the order,
+    # so a replayed submit cannot produce a second order.
+    conn.execute("BEGIN IMMEDIATE")
+    try:
+        BACKEND.payments.consume_approval(
+            conn, flow_id=intent["flow_id"], owner=owner,
+            amount_minor=amount_minor, currency="USD",
+            fingerprint=fingerprint)
+        conn.commit()
+    except Exception:
+        conn.rollback()
+        return redirect(
+            ctx,
+            "/orderCheckout?" + urlencode(
+                {"error": "That payment was already used. "
+                          "Start a new checkout to continue."}),
+        )
+    ship_to = {"firstName": firstName, "lastName": lastName,
+               "address1": address1, "city": city, "state": stateDropdown,
+               "postalCode": postalCode, "phone": phoneNumber}
+    order_number = store.place_order(
+        conn, ctx.token, ctx.subject_id, items, ship_to, scenario)
+    if ctx.subject_id:
+        store.add_address(conn, ctx.subject_id, {
+            "firstName": firstName, "lastName": lastName,
+            "address1": address1, "city": city,
+            "stateDropdown": stateDropdown, "postalCode": postalCode,
+            "phoneNumber": phoneNumber})
+    store.clear_cart(conn, ctx.token)
+    return redirect(ctx, f"/orderConfirmation?order={order_number}")
+
+
+@app.get("/orderConfirmation", response_class=HTMLResponse)
+def order_confirmation(request: Request, order: str = "") -> Response:
+    ctx = Ctx(request)
+    conn = connection()
+    if not order:
+        return redirect(ctx, "/myAccount/myOrders")
+    record = store.find_order(conn, order)
+    if not record:
+        return not_found(ctx)
+    body = (
+        f'<div class="wrap"><h1 class="page">Thank you for your order</h1>'
+        f'<div class="card"><p>Order number <strong>'
+        f'{escape(record["order_number"])}</strong></p>'
+        f'<p>Status: {escape(record["status"])}</p>'
+        f'<p>Total: {money(record["total"])}</p>'
+        f'<p class="muted">Recorded in this site\'s local ledger only.</p>'
+        f'<p><a class="zenbtn zenbtn-primary" href="/myAccount/myOrders">'
+        f"View my orders</a></p></div></div>"
+    )
+    return respond(ctx, page("Order Confirmation | Zenni Optical", body,
+                             ctx.state(conn)))
+
+
+@app.get("/trackOrder", response_class=HTMLResponse)
+def track_order(request: Request, order: str = "") -> Response:
+    ctx = Ctx(request)
+    conn = connection()
+    record = store.find_order(conn, order) if order else None
+    if order and not record:
+        result = '<p class="flash error">No order matches that number.</p>'
+    elif record:
+        result = (
+            f'<div class="card"><strong>{escape(record["order_number"])}'
+            f'</strong><p>Status: {escape(record["status"])}</p>'
+            f'<p>Placed {escape(record["placed_at"])}</p>'
+            f'<p>Total {money(record["total"])}</p></div>'
+        )
+    else:
+        result = ""
+    body = (
+        f'<div class="wrap"><h1 class="page">Track My Order</h1>'
+        f'<form method="get" action="/trackOrder" class="grid">'
+        f'<label class="full">Order number'
+        f'<input name="order" value="{escape(order)}" placeholder="ZO1000001">'
+        f"</label>"
+        f'<div class="full"><button class="zenbtn zenbtn-primary">Track'
+        f"</button></div></form>{result}</div>"
+    )
+    return respond(ctx, page("Track My Order | Zenni Optical", body,
+                             ctx.state(conn)))
+
+
+# --------------------------------------------------------------------------
+# Account
+
+
+def _account_nav(current: str) -> str:
+    blocks = []
+    for title, links in nav.ACCOUNT_NAV:
+        items = "".join(
+            f'<li><a href="{escape(href)}" '
+            f'aria-current="{"page" if href == current else "false"}">'
+            f"{escape(text)}</a></li>"
+            for text, href in links
+        )
+        blocks.append(f"<h4>{escape(title)}</h4><ul>{items}</ul>")
+    blocks.append(
+        "<h4>Help &amp; Support</h4><ul>"
+        '<li><a href="/help">Help Center</a></li>'
+        '<li><form method="post" action="/logout">'
+        '<button class="linkbtn">Sign Out</button></form></li></ul>'
+    )
+    return f'<nav>{"".join(blocks)}</nav>'
+
+
+def _account_page(ctx: Ctx, request: Request, current: str, title: str,
+                  inner: str) -> Response:
+    body = (
+        f'<div class="wrap"><h1 class="page">My Account</h1>'
+        f'<div class="account">{_account_nav(current)}'
+        f"<section>{inner}</section></div></div>"
+    )
+    return respond(ctx, page(f"{title} | Zenni Optical", body,
+                             ctx.state(connection())))
+
+
+@app.get("/myAccount/myDashBoard", response_class=HTMLResponse)
+def account_dashboard(request: Request) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    conn = connection()
+    order_list = store.orders(conn, ctx.subject_id, ctx.token)
+    scripts = store.prescriptions(conn, ctx.subject_id or "")
+    spent = round(sum(o["total"] for o in order_list), 2)
+    tiers = "".join(
+        f"<div><strong>{escape(name)}</strong><br>"
+        f'<span class="muted">{escape(threshold)}</span></div>'
+        for name, threshold in [("Fan", "Starter"), ("Friend", "$150+"),
+                                ("VIP", "$250+"), ("Icon", "$500+")]
+    )
+    orders_block = (
+        f"<p>{len(order_list)} order(s) placed.</p>"
+        f'<a class="zenbtn zenbtn-primary-outline" href="/myAccount/myOrders">'
+        "View orders</a>"
+        if order_list else
+        "<h2>No Orders Yet</h2><p>View and manage your orders here after "
+        'making a purchase.</p><a class="zenbtn zenbtn-primary" '
+        'href="/b/sunglasses">Start Shopping</a>'
+    )
+    scripts_block = (
+        f"<p>{len(scripts)} saved prescription(s).</p>"
+        if scripts else
+        "<h2>No Saved Prescriptions</h2><p>Keep your glasses prescription on "
+        "file with us for quick and easy reordering.</p>"
+        '<a class="zenbtn zenbtn-primary-outline" '
+        'href="/myAccount/myPrescription">Add Prescription</a>'
+    )
+    inner = (
+        f'<div class="card"><h2 style="margin-top:0">Hi, '
+        f'{escape(ctx.display_name)}</h2>'
+        f'<p class="muted">Store Credit: $0.00</p></div>'
+        f'<div class="card"><h2 style="margin-top:0">Zenni Rewards</h2>'
+        f"<p>Status: Fan &middot; Points: 0 ($0 value) &middot; "
+        f"Total Spent: {money(spent)}</p>"
+        f'<div class="tiers">{tiers}</div></div>'
+        f'<div class="card">{orders_block}</div>'
+        f'<div class="card">{scripts_block}</div>'
+    )
+    return _account_page(ctx, request, "/myAccount/myDashBoard", "My Account",
+                         inner)
+
+
+@app.get("/myAccount/myOrders", response_class=HTMLResponse)
+def account_orders(request: Request) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    conn = connection()
+    order_list = store.orders(conn, ctx.subject_id, ctx.token)
+    if not order_list:
+        inner = (
+            '<div class="empty"><h2>No Orders Yet</h2>'
+            "<p>View and manage your orders here after making a purchase.</p>"
+            '<a class="zenbtn zenbtn-primary" href="/b/sunglasses">'
+            "Start Shopping</a></div>"
+        )
+    else:
+        cards = []
+        for record in order_list:
+            lines = "".join(
+                f"<li>{escape(line['found'][1]['color'] or '')} "
+                f"{escape(line['found'][0]['shape'])} &times;"
+                f"{line['quantity']} &mdash; {money(line['unit_price'])}</li>"
+                for line in record["lines"] if line["found"]
+            )
+            cards.append(
+                f'<div class="card"><strong>{escape(record["order_number"])}'
+                f'</strong> <span class="muted">{escape(record["placed_at"])}'
+                f'</span><p>Status: {escape(record["status"])}</p>'
+                f"<ul>{lines}</ul>"
+                f"<p>Subtotal {money(record['subtotal'])} &middot; "
+                f"Shipping {money(record['shipping'])} &middot; "
+                f"Tax {money(record['tax'])} &middot; "
+                f"<strong>Total {money(record['total'])}</strong></p>"
+                f'<a class="linkbtn" href="/trackOrder?order='
+                f'{escape(record["order_number"])}">Track this order</a></div>'
+            )
+        inner = "".join(cards)
+    return _account_page(ctx, request, "/myAccount/myOrders", "Orders", inner)
+
+
+@app.get("/myAccount/myFavorites", response_class=HTMLResponse)
+def account_favorites(request: Request) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    conn = connection()
+    saved = store.favorites(conn, ctx.token)
+    products = [
+        catalog.find_sku(sku)[0] for sku in saved if catalog.find_sku(sku)
+    ]
+    unique = {p["product_id"]: p for p in products}
+    if not unique:
+        inner = (
+            '<div class="empty"><h2>No Saved Favorites</h2>'
+            "<p>Save items you love to your favorites list and access them "
+            'here anytime.</p><a class="zenbtn zenbtn-primary" '
+            'href="/b/sunglasses">Show now</a></div>'
+        )
+    else:
+        inner = render.product_grid(list(unique.values()), saved)
+    return _account_page(ctx, request, "/myAccount/myFavorites", "Favorites",
+                         inner)
+
+
+@app.get("/myAccount/myPrescription", response_class=HTMLResponse)
+def account_prescription(request: Request) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    conn = connection()
+    saved = store.prescriptions(conn, ctx.subject_id or "")
+    rows = "".join(
+        f'<div class="card"><strong>{escape(row["label"])}</strong>'
+        f'<p>OD {escape(row["od_sphere"])} &middot; OS '
+        f'{escape(row["os_sphere"])} &middot; PD {escape(row["pd"])}</p></div>'
+        for row in saved
+    )
+    inner = (
+        (rows or '<div class="empty"><h2>No Saved Prescriptions</h2>'
+                 "<p>Keep your glasses prescription on file with us for quick "
+                 "and easy reordering.</p></div>")
+        + '<div class="card"><h2 style="margin-top:0">Add Prescription</h2>'
+        '<form method="post" action="/myAccount/myPrescription" class="grid">'
+        '<label>Label<input name="label" required value="My prescription">'
+        "</label>"
+        '<label>PD<input name="pd" required value="63"></label>'
+        '<label>OD sphere<input name="od" required value="-1.00"></label>'
+        '<label>OS sphere<input name="os" required value="-1.25"></label>'
+        '<div class="full"><button class="zenbtn zenbtn-primary">Save'
+        "</button></div></form></div>"
+    )
+    return _account_page(ctx, request, "/myAccount/myPrescription",
+                         "My Prescription", inner)
+
+
+@app.post("/myAccount/myPrescription")
+def account_prescription_add(request: Request, label: str = Form(...),
+                             od: str = Form(...), os: str = Form(...),
+                             pd: str = Form(...)) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    store.add_prescription(connection(), ctx.subject_id or "", label, od, os,
+                           pd)
+    return redirect(ctx, "/myAccount/myPrescription")
+
+
+@app.get("/myAccount/addressBook", response_class=HTMLResponse)
+def account_addresses(request: Request) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    conn = connection()
+    saved = store.addresses(conn, ctx.subject_id or "")
+    rows = "".join(
+        f'<div class="card"><strong>{escape(row["first_name"])} '
+        f'{escape(row["last_name"])}</strong><p>{escape(row["address1"])}<br>'
+        f'{escape(row["city"])}, {escape(row["state"])} '
+        f'{escape(row["postal_code"])}</p></div>'
+        for row in saved
+    )
+    states = "".join(f"<option>{code}</option>" for code in US_STATES)
+    inner = (
+        (rows or '<div class="empty"><h2>No saved addresses</h2>'
+                 "<p>Addresses you use at checkout are saved here.</p></div>")
+        + '<div class="card"><h2 style="margin-top:0">Add an address</h2>'
+        '<form method="post" action="/myAccount/addressBook" class="grid">'
+        '<label>Firstname<input name="firstName" required></label>'
+        '<label>Lastname<input name="lastName" required></label>'
+        '<label class="full">Address<input name="address1" required></label>'
+        '<label>City<input name="city" required></label>'
+        f'<label>State/Province<select name="stateDropdown">{states}</select>'
+        "</label>"
+        '<label>Zip code<input name="postalCode" required></label>'
+        '<label>Phone<input name="phoneNumber" type="tel"></label>'
+        '<div class="full"><button class="zenbtn zenbtn-primary">Save address'
+        "</button></div></form></div>"
+    )
+    return _account_page(ctx, request, "/myAccount/addressBook", "Addresses",
+                         inner)
+
+
+@app.post("/myAccount/addressBook")
+def account_address_add(request: Request, firstName: str = Form(...),
+                        lastName: str = Form(...), address1: str = Form(...),
+                        city: str = Form(...), stateDropdown: str = Form(...),
+                        postalCode: str = Form(...),
+                        phoneNumber: str = Form("")) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    store.add_address(connection(), ctx.subject_id or "", {
+        "firstName": firstName, "lastName": lastName, "address1": address1,
+        "city": city, "stateDropdown": stateDropdown,
+        "postalCode": postalCode, "phoneNumber": phoneNumber})
+    return redirect(ctx, "/myAccount/addressBook")
+
+
+SIMPLE_ACCOUNT_PAGES = {
+    "myGiftCardBalance": ("Gift Card Balance",
+                          "<h2>Gift Card Balance</h2><p>Balance: $0.00</p>"
+                          "<p class=\"muted\">Gift cards in this clone are "
+                          "local ledger entries only.</p>"),
+    "myStoreCredit": ("Store Credit",
+                      "<h2>Store Credit</h2><p>Store Credit: $0.00</p>"),
+    "myRewardDashboard": ("Zenni Rewards",
+                          "<h2>Zenni Rewards</h2><p>Status: Fan &middot; "
+                          "Points: 0 ($0 value)</p>"),
+    "myReferAFriend": ("Refer Friends",
+                       "<h2>Refer Friends, Earn $15</h2>"
+                       "<p>Your local referral link: "
+                       "<code>/register?ref=zenni-shopper</code></p>"),
+    "paymentMethods": ("Payments",
+                       "<h2>Payments</h2><p>No stored payment methods. This "
+                       "clone uses the local sandbox payment adapter and never "
+                       "collects card data.</p>"),
+    "myCommunicationPreferences": (
+        "Communication Preferences",
+        "<h2>Communication Preferences</h2>"
+        "<p>Email updates are written to the local outbox only.</p>"),
+    "language": ("Language", "<h2>Language</h2><p>English (United States)</p>"),
+}
+
+
+@app.get("/myAccount/myAccountSetting", response_class=HTMLResponse)
+def account_settings(request: Request) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    inner = (
+        f'<div class="card"><h2 style="margin-top:0">Personal Information</h2>'
+        f"<p>Name: {escape(ctx.display_name)}</p>"
+        f'<p class="muted">Managed by this site\'s local account store.</p>'
+        f"</div>"
+    )
+    return _account_page(ctx, request, "/myAccount/myAccountSetting",
+                         "Personal Information", inner)
+
+
+@app.get("/myAccount/{slug}", response_class=HTMLResponse)
+def account_simple(slug: str, request: Request) -> Response:
+    ctx = Ctx(request)
+    if not ctx.account:
+        return _login_redirect(ctx, request)
+    entry = SIMPLE_ACCOUNT_PAGES.get(slug)
+    if not entry:
+        return not_found(ctx)
+    title, inner = entry
+    return _account_page(ctx, request, f"/myAccount/{slug}", title,
+                         f'<div class="card">{inner}</div>')
+
+
+# --------------------------------------------------------------------------
+# Content
+
+
+HELP_ARTICLES: dict[str, tuple[str, str]] = {
+    "shipping-returns/shipping-delivery": (
+        "Shipping & Delivery",
+        "<p>Standard shipping is free on orders over $65. Orders under that "
+        "threshold add a $4.95 standard shipping charge, calculated at "
+        "checkout.</p>"),
+    "prescriptions/prescription-faq": (
+        "Prescription FAQ",
+        "<p>Save a prescription in your account to reuse it at checkout. "
+        "Pupillary distance (PD) is required for prescription lenses.</p>"),
+    "lens-types-coatings/lens-faqs": (
+        "Lens FAQ",
+        "<p>Every lens includes 100% UV protection and a scratch-resistant "
+        "coating. Anti-reflective, water-resistant, oil-resistant and "
+        "anti-fog coatings are optional upgrades in the lens builder.</p>"),
+    "specialty-lenses-sunglasses/sunglasses-clip-ons": (
+        "Sunglasses & Clip-Ons",
+        "<p>Permanent tint sunglasses stay dark indoors and out. Polarized "
+        "tints reduce glare from water and roads.</p>"),
+    "frames-fitting/virtual-try-on": (
+        "Virtual Try-On",
+        "<p>The offline clone previews frames from local product photography "
+        "instead of a camera capture.</p>"),
+    "ordering-payment/contact-us": (
+        "Contact Us",
+        "<p>Support hours and channels are informational in this clone; no "
+        "message is delivered off this machine.</p>"),
+}
+
+
+@app.get("/help", response_class=HTMLResponse)
+def help_center(request: Request) -> Response:
+    ctx = Ctx(request)
+    links = "".join(
+        f'<li><a href="/help/{escape(slug)}">{escape(title)}</a></li>'
+        for slug, (title, _) in HELP_ARTICLES.items()
+    )
+    body = (
+        f'<div class="wrap"><h1 class="page">Customer Service</h1>'
+        f'<div class="card"><ul>{links}</ul></div>'
+        f'<div class="card"><h2 style="margin-top:0">Quick links</h2>'
+        f'<ul><li><a href="/c/faq">Frequently Asked Questions</a></li>'
+        f'<li><a href="/trackOrder">Track My Order</a></li></ul></div></div>'
+    )
+    return respond(ctx, page("Customer Service | Zenni Optical", body,
+                             ctx.state(connection())))
+
+
+@app.get("/help/{slug:path}", response_class=HTMLResponse)
+def help_article(slug: str, request: Request) -> Response:
+    ctx = Ctx(request)
+    entry = HELP_ARTICLES.get(slug)
+    if not entry:
+        return not_found(ctx)
+    title, content = entry
+    body = (
+        f'<div class="wrap"><h1 class="page">{escape(title)}</h1>'
+        f'<div class="card tabpanel">{content}</div>'
+        f'<p><a class="linkbtn" href="/help">Back to Customer Service</a></p>'
+        f"</div>"
+    )
+    return respond(ctx, page(f"{title} | Zenni Optical", body,
+                             ctx.state(connection())))
+
+
+FAQ = [
+    ("How long does shipping take?",
+     "Standard delivery arrives in about 7&ndash;10 business days once your "
+     "lenses are cut."),
+    ("What is the return policy?",
+     "Returns are accepted within 30 days by mail."),
+    ("Do I need my pupillary distance?",
+     "Yes, PD is required for prescription lenses. Non-prescription "
+     "sunglasses do not need it."),
+    ("Can I use my insurance or FSA/HSA?",
+     "Insurance and FSA/HSA reimbursement are described here for parity; this "
+     "clone processes no real benefit claim."),
+]
+
+
+@app.get("/c/faq", response_class=HTMLResponse)
+def faq(request: Request) -> Response:
+    ctx = Ctx(request)
+    items = "".join(
+        f"<details class=\"facet\"><summary>{escape(question)}</summary>"
+        f"<p>{answer}</p></details>"
+        for question, answer in FAQ
+    )
+    body = (
+        f'<div class="wrap"><h1 class="page">Frequently Asked Questions</h1>'
+        f'<div class="card">{items}</div></div>'
+    )
+    return respond(ctx, page("FAQ | Zenni Optical", body,
+                             ctx.state(connection())))
+
+
+STATIC_CONTENT: dict[str, tuple[str, str]] = {
+    "/sunglasses-guide": (
+        "Sunglasses Guide",
+        "<p>Permanent tint, polarized and Blokz sunglass lenses each suit a "
+        "different kind of glare. Start from the shape that fits your face, "
+        "then choose a tint in the lens builder.</p>"),
+    "/discounts-promo-codes": (
+        "Everyday Value & Promotions",
+        "<p>Free standard shipping applies automatically on orders over "
+        "$65.</p>"),
+    "/measuring-pd-infographic": (
+        "How to Measure Pupillary Distance (PD)",
+        "<p>Measure from the centre of one pupil to the centre of the other, "
+        "in millimetres. Most adults fall between 54mm and 74mm.</p>"),
+    "/measure-eyeglass-frame-size-how-to": (
+        "How to Measure Your Frame Size",
+        "<p>Frame size is printed on the inside of the temple as three "
+        "numbers: lens width, bridge width and temple length, all in "
+        "millimetres. Compare them against a pair that already fits.</p>"
+        "<p>This catalogue groups lens width into XS, S, M, L and XL, which is "
+        "the Frame Sizes facet on every listing page.</p>"),
+    "/glasses-for-face-shape": (
+        "Glasses for Your Face Shape",
+        "<p>Round faces suit rectangle and square frames; square faces suit "
+        "round and oval frames; heart shapes suit aviators and cat-eyes.</p>"),
+}
+
+
+@app.get("/{slug:path}", response_class=HTMLResponse)
+def static_content(slug: str, request: Request) -> Response:
+    ctx = Ctx(request)
+    entry = STATIC_CONTENT.get("/" + slug)
+    if not entry:
+        return not_found(ctx)
+    title, content = entry
+    body = (
+        f'<div class="wrap"><h1 class="page">{escape(title)}</h1>'
+        f'<div class="card tabpanel">{content}</div></div>'
+    )
+    return respond(ctx, page(f"{title} | Zenni Optical", body,
+                             ctx.state(connection())))
+
+
+def not_found(ctx: Ctx) -> HTMLResponse:
+    body = (
+        '<div class="wrap"><div class="empty">'
+        "<h1 class=\"page\">We can't find that page</h1>"
+        "<p>The page you were looking for is not part of this offline "
+        "clone.</p>"
+        '<p><a class="zenbtn zenbtn-primary zenbtn-large" href="/">'
+        "Back to home</a></p></div></div>"
+    )
+    return respond(ctx, page("Page Not Found | Zenni Optical", body,
+                             ctx.state(connection())), status=404)

tasks/zennioptical/solution/site/implementation/clone/backend/site_backend_integration.py

@@ -0,0 +1,112 @@
+"""Generated, site-bound backend integration seam."""
+
+from __future__ import annotations
+
+import importlib
+import json
+import os
+import sqlite3
+from pathlib import Path
+from typing import Any, Callable
+
+from websitebench.local_clone_auth import LocalAuthStore
+from websitebench.site_backend import (
+    SiteBackend,
+    load_runtime,
+    serve_jsonl,
+    validate_allowlist,
+)
+
+
+DEFAULT_RUNTIME_PATH = (
+    Path(__file__).resolve().parents[2] / "backend" / "runtime.json"
+)
+BRIDGE_DESCRIPTOR_PATH = (
+    Path(__file__).resolve().parents[2] / "backend" / "node-bridge.json"
+)
+
+
+def _declared_hook(
+    declaration: str | None,
+) -> Callable[[sqlite3.Connection], None] | None:
+    if declaration is None:
+        return None
+    module_name, function_name = declaration.split(":", 1)
+    module = importlib.import_module(module_name)
+    hook: Any = getattr(module, function_name, None)
+    if not callable(hook):
+        raise RuntimeError(f"declared backend hook is not callable: {declaration}")
+    actual = f"{hook.__module__}:{hook.__name__}"
+    if actual != declaration:
+        raise RuntimeError(
+            f"declared backend hook resolved as {actual!r}, expected {declaration!r}"
+        )
+    return hook
+
+
+def open_site_services() -> tuple[SiteBackend, LocalAuthStore]:
+    """Open one bound database; never omit the site id for permanent auth."""
+
+    runtime_path = Path(
+        os.environ.get(
+            "WEBSITEBENCH_SITE_BACKEND_RUNTIME",
+            str(DEFAULT_RUNTIME_PATH),
+        )
+    ).resolve()
+    runtime = load_runtime(runtime_path)
+    migration_hook = _declared_hook(runtime.migration_hook)
+    seed_hook = _declared_hook(runtime.seed_hook)
+    deployed_database = os.environ.get(
+        "WEBSITEBENCH_SITE_BACKEND_DATABASE",
+    )
+    if deployed_database is None:
+        backend = SiteBackend.open(
+            runtime_path,
+            migration_hook=migration_hook,
+            seed_hook=seed_hook,
+        )
+    else:
+        database_path = Path(deployed_database).resolve()
+        if database_path.name != runtime.database_filename:
+            raise RuntimeError(
+                "deployed database filename does not match runtime contract"
+            )
+        backend = SiteBackend.open(
+            json.loads(runtime_path.read_text(encoding="utf-8")),
+            data_root=database_path.parent,
+            migration_hook=migration_hook,
+            seed_hook=seed_hook,
+        )
+        if backend.lifecycle.database_path != database_path:
+            raise RuntimeError(
+                "deployed database path does not match backend preflight"
+            )
+    backend.lifecycle.initialize()
+    auth = LocalAuthStore(
+        backend.lifecycle.database_path,
+        site_id=backend.config.site_id,
+    )
+    auth.ensure_schema()
+    return backend, auth
+
+
+def run_stdio_bridge() -> None:
+    """Run only operations frozen in this site's descriptor."""
+
+    backend, auth = open_site_services()
+    descriptor = json.loads(BRIDGE_DESCRIPTOR_PATH.read_text(encoding="utf-8"))
+    allowed = validate_allowlist(
+        descriptor,
+        expected_site_id=backend.config.site_id,
+    )
+    serve_jsonl(backend, auth, allowed, sys.stdin, sys.stdout)
+
+
+if __name__ == "__main__":
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(prog="websitebench-node-backend-bridge")
+    parser.add_argument("--stdio", action="store_true", required=True)
+    parser.parse_args()
+    run_stdio_bridge()

tasks/zennioptical/solution/site/implementation/clone/data/accessories.json

@@ -0,0 +1,242 @@
+[
+ {
+  "sku": "A60122619",
+  "href": "/p/eyeglass-chain/A601226/A60122619",
+  "name": "Rose Gold Metal Eyeglass Chain",
+  "price": 3.95,
+  "rating": 4.3,
+  "review_count": 13,
+  "badge": "Best seller",
+  "image": "/static/accessories/A60122619-accessories-01.jpg"
+ },
+ {
+  "sku": "A110400030",
+  "href": "/p/repair-kit/A1104000/A110400030",
+  "name": "White Eyeglasses Repair Kit",
+  "price": 6.95,
+  "rating": 3.9,
+  "review_count": 43,
+  "badge": "Best seller",
+  "image": "/static/accessories/A110400030-accessories-01.jpg"
+ },
+ {
+  "sku": "A110300224",
+  "href": "/p/pre-moistened-lens-wipe/A1103002/A110300224",
+  "name": "Green Pre-Moistened Lens Wipe",
+  "price": 9.95,
+  "rating": 2.8,
+  "review_count": 5,
+  "badge": null,
+  "image": "/static/accessories/A110300224-accessories-01.jpg"
+ },
+ {
+  "sku": "A90100121",
+  "href": "/p/eyeglass-case/A901001/A90100121",
+  "name": "Black Deluxe Tri-Fold Eyeglass Case",
+  "price": 6.95,
+  "rating": 4.6,
+  "review_count": 106,
+  "badge": "Top rated",
+  "image": "/static/accessories/A90100121-accessories-01.jpg"
+ },
+ {
+  "sku": "A90100424",
+  "href": "/p/eyeglass-case/A901004/A90100424",
+  "name": "Zenni Teal Travel Case (4-Frame)",
+  "price": 17.95,
+  "rating": 4.9,
+  "review_count": 11,
+  "badge": null,
+  "image": "/static/accessories/A90100424-accessories-01.jpg"
+ },
+ {
+  "sku": "A110200030",
+  "href": "/p/cleaning-kit/A1102000/A110200030",
+  "name": "White Lens Spray Kit",
+  "price": 4.95,
+  "rating": 4.2,
+  "review_count": 26,
+  "badge": "Best seller",
+  "image": "/static/accessories/A110200030-accessories-01.jpg"
+ },
+ {
+  "sku": "A90103724",
+  "href": "/p/hard-shell-eyeglass-case/A901037/A90103724",
+  "name": "Zenni Teal Hard-Shell Eyeglass Case",
+  "price": 2.95,
+  "rating": null,
+  "review_count": null,
+  "badge": "Best seller",
+  "image": "/static/accessories/A90103724-accessories-01.jpg"
+ },
+ {
+  "sku": "A50100015",
+  "href": "/p/eyeglass-case/A501000/A50100015",
+  "name": "Brown Deluxe Eyeglass Case",
+  "price": 4.95,
+  "rating": 4.4,
+  "review_count": 121,
+  "badge": "Best seller",
+  "image": "/static/accessories/A50100015-accessories-01.jpg"
+ },
+ {
+  "sku": "A90104821",
+  "href": "/p/eyeglass-case/A901048/A90104821",
+  "name": "Black Pocket Clip-On Case with Keyring",
+  "price": 2.95,
+  "rating": 2.8,
+  "review_count": 6,
+  "badge": "Best seller",
+  "image": "/static/accessories/A90104821-accessories-01.jpg"
+ },
+ {
+  "sku": "A60105818",
+  "href": "/p/eyeglass-case/A601058/A60105818",
+  "name": "Red Artist Deluxe Eyewear Lunar New Year Case",
+  "price": 9.95,
+  "rating": null,
+  "review_count": null,
+  "badge": null,
+  "image": "/static/accessories/A60105818-accessories-01.jpg"
+ },
+ {
+  "sku": "A60106042",
+  "href": "/p/eyeglass-case/A601060/A60106042",
+  "name": "Orange Year of the Horse Hard-Shell Eyeglass Case",
+  "price": 3.95,
+  "rating": null,
+  "review_count": null,
+  "badge": null,
+  "image": "/static/accessories/A60106042-accessories-01.jpg"
+ },
+ {
+  "sku": "A60105942",
+  "href": "/p/eyeglass-case/A601059/A60105942",
+  "name": "Orange Lunar New Year Zip-Up Eyeglass Bag",
+  "price": 19.95,
+  "rating": null,
+  "review_count": null,
+  "badge": "Best seller",
+  "image": "/static/accessories/A60105942-accessories-01.jpg"
+ },
+ {
+  "sku": "A60105621",
+  "href": "/p/eyeglass-case/A601056/A60105621",
+  "name": "Black Deluxe Eyewear Case",
+  "price": 3.95,
+  "rating": 4.4,
+  "review_count": 17,
+  "badge": null,
+  "image": "/static/accessories/A60105621-accessories-01.jpg"
+ },
+ {
+  "sku": "A60104517",
+  "href": "/p/eyeglass-case/A601045/A60104517",
+  "name": "Purple Year of the Snake Hard-Shell Eyeglass Case",
+  "price": 3.95,
+  "rating": 4.4,
+  "review_count": 7,
+  "badge": "Best seller",
+  "image": "/static/accessories/A60104517-accessories-01.jpg"
+ },
+ {
+  "sku": "A60105624",
+  "href": "/p/eyeglass-case/A601056/A60105624",
+  "name": "Green Deluxe Eyewear Case",
+  "price": 3.95,
+  "rating": 4.4,
+  "review_count": 17,
+  "badge": null,
+  "image": "/static/accessories/A60105624-accessories-01.jpg"
+ },
+ {
+  "sku": "A90105118",
+  "href": "/p/lunar-new-year-hard-shell-eyeglass-case/A901051/A90105118",
+  "name": "Red Year of the Dragon Hard-Shell Eyeglass Case",
+  "price": 3.95,
+  "rating": null,
+  "review_count": 5,
+  "badge": null,
+  "image": "/static/accessories/A90105118-accessories-01.jpg"
+ },
+ {
+  "sku": "A60123323",
+  "href": "/p/adult-silicone-eyewear-retainer/A601233/A60123323",
+  "name": "Clear Silicone Eyewear Retainer 2-Pack",
+  "price": 6.95,
+  "rating": null,
+  "review_count": null,
+  "badge": null,
+  "image": "/static/accessories/A60123323-accessories-01.jpg"
+ },
+ {
+  "sku": "A110100023",
+  "href": "/p/nose-pad/A1101000/A110100023",
+  "name": "Translucent Adhesive Nose Pads",
+  "price": 1.95,
+  "rating": 2.6,
+  "review_count": 40,
+  "badge": "Best seller",
+  "image": "/static/accessories/A110100023-accessories-01.jpg"
+ },
+ {
+  "sku": "A60105615",
+  "href": "/p/eyeglass-case/A601056/A60105615",
+  "name": "Brown Deluxe Eyewear Case",
+  "price": 3.95,
+  "rating": 4.4,
+  "review_count": 17,
+  "badge": null,
+  "image": "/static/accessories/A60105615-accessories-01.jpg"
+ },
+ {
+  "sku": "A60105616",
+  "href": "/p/eyeglass-case/A601056/A60105616",
+  "name": "Blue Deluxe Eyewear Case",
+  "price": 3.95,
+  "rating": 4.4,
+  "review_count": 17,
+  "badge": null,
+  "image": "/static/accessories/A60105616-accessories-01.jpg"
+ },
+ {
+  "sku": "A60105630",
+  "href": "/p/eyeglass-case/A601056/A60105630",
+  "name": "White Deluxe Eyewear Case",
+  "price": 3.95,
+  "rating": 4.4,
+  "review_count": 17,
+  "badge": null,
+  "image": "/static/accessories/A60105630-accessories-01.jpg"
+ },
+ {
+  "sku": "A60122230",
+  "href": "/p/eyeglass-chain/A601222/A60122230",
+  "name": "White Pearl Eyeglass Chain",
+  "price": 4.95,
+  "rating": 4.4,
+  "review_count": 5,
+  "badge": null,
+  "image": "/static/accessories/A60122230-accessories-01.jpg"
+ },
+ {
+  "sku": "A60123321",
+  "href": "/p/adult-silicone-eyewear-retainer/A601233/A60123321",
+  "name": "Black Silicone Eyewear Retainer 2-Pack",
+  "price": 6.95,
+  "rating": null,
+  "review_count": null,
+  "badge": null,
+  "image": "/static/accessories/A60123321-accessories-01.jpg"
+ },
+ {
+  "sku": "A90104816",
+  "href": "/p/eyeglass-case/A901048/A90104816",
+  "name": "Zenni Teal Pocket Clip-On Case with Keyring",
+  "price": 2.95,
+  "rating": 2.8,
+  "review_count": 6,
+  "badge": null,
+  "image": "/static/accessories/A90104816-accessories-01.jpg"
+ }
+]

tasks/zennioptical/solution/site/implementation/clone/requirements.txt

@@ -0,0 +1,2 @@
+fastapi>=0.115
+uvicorn>=0.30