Ship a Site

const origin = 'https://harbor-tides.example'; // the Site's origin, for sitemap.xml

// Every record in pages/: home.json is /, contact/sent.json is /contact/sent.
const pages: { path: string; page: Page }[] = [];
for (const file of (await readdir('pages', { recursive: true })).filter((f) => f.endsWith('.json'))) {
  const page = PageSchema.parse(JSON.parse(await readFile(`pages/${file}`, 'utf8')));
  pages.push({ path: file === 'home.json' ? '/' : `/${file.replace(/\.json$/, '')}`, page });
}
pages.sort((a, b) => a.path.localeCompare(b.path));

/** Every record under `dir`, parsed, with its address: home.json is /, contact/sent.json is /contact/sent. */
export async function readRecords(dir = 'pages'): Promise<{ path: string; page: Page }[]> {
  const out: { path: string; page: Page }[] = [];
  for (const file of (await readdir(dir, { recursive: true })).filter((f) => f.endsWith('.json')).sort()) {
    const result = PageSchema.safeParse(JSON.parse(await readFile(join(dir, file), 'utf8')));
    if (!result.success) {
      const [{ path, message }] = result.error.issues;
      throw new Error(`${dir}/${file}: ${path.join('.')}: ${message}`);
    }
    out.push({ path: file === 'home.json' ? '/' : `/${file.replace(/\.json$/, '')}`, page: result.data });
  }
  return out;
}

/** The file a static host serves for an address: / is index.html, /pricing is pricing.html. */
export const fileFor = (path: string) => (path === '/' ? 'index.html' : `${path.slice(1)}.html`);

// A Site renders whole or not at all: a 404 page, and one Theme for every Page.
if (!pages.some((p) => p.path === '/404')) throw new Error('pages/404.json is missing: a Site has a 404 page');
const themes = new Set(pages.map((p) => p.page.theme));
if (themes.size > 1) throw new Error(`the records name ${themes.size} Themes, ${[...themes].join(' and ')}: a Site has one`);

const write = async (file: string, text: string) => {
  await mkdir(dirname(file), { recursive: true });
  await writeFile(file, text);
  console.log(file);
};
for (const { path, page } of pages) await write(`dist${path === '/' ? '/index' : path}.html`, renderPage(page));

// Every page a search engine may list: not the 404, and no record marked noindex.
const listed = pages.filter((p) => p.path !== '/404' && !p.page.meta?.noindex);
await write(
  'dist/sitemap.xml',
  `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${listed.map((p) => `  <url><loc>${origin}${p.path}</loc></url>`).join('\n')}\n</urlset>\n`,
);
await write('dist/robots.txt', `User-agent: *\nAllow: /\nSitemap: ${origin}/sitemap.xml\n`);

/**
 * Every record in pages/ as a page of a Vite project: rendered on each request
 * under `vite dev`, so an edit to a record shows on reload, and written into
 * the build's outDir by `vite build`.
 */
export function mdxuiPages({ dir = 'pages' } = {}): Plugin {
  let config: ResolvedConfig;
  return {
    name: 'mdxui-pages',
    configResolved(resolved) {
      config = resolved;
    },
    configureServer(server) {
      server.middlewares.use(async (req, res, next) => {
        const path = new URL(req.url ?? '/', 'http://dev').pathname.replace(/(.)\/$/, '$1');
        try {
          const hit = (await readRecords(join(config.root, dir))).find((r) => r.path === path);
          if (!hit) return next();
          res.setHeader('content-type', 'text/html; charset=utf-8');
          res.end(renderPage(hit.page));
        } catch (error) {
          next(error); // a refused record answers with its path and bound
        }
      });
    },
    async writeBundle(_options, bundle) {
      const out = resolve(config.root, config.build.outDir);
      for (const { path, page } of await readRecords(join(config.root, dir))) {
        const file = fileFor(path);
        if (file in bundle) throw new Error(`${file} is already in the build: give the record or the entry another address`);
        await mkdir(dirname(join(out, file)), { recursive: true });
        await writeFile(join(out, file), renderPage(page));
      }
    },
  };
}

/**
 * Run after `react-router build`: every record in pages/ becomes a file in the
 * prerendered client build, beside the routes React Router wrote. A record
 * never replaces a prerendered route; the landing record takes index.html,
 * the address React Router gives its SPA fallback when / is not prerendered.
 */
export async function renderInto(client = 'build/client', dir = 'pages'): Promise<string[]> {
  const written: string[] = [];
  for (const { path, page } of await readRecords(dir)) {
    const file = path === '/' ? 'index.html' : `${path.slice(1)}/index.html`;
    const taken = await access(join(client, file)).then(() => true, () => false);
    if (taken && path !== '/') throw new Error(`${file} is a prerendered route: give the record or the route another address`);
    await mkdir(dirname(join(client, file)), { recursive: true });
    await writeFile(join(client, file), renderPage(page));
    written.push(file);
  }
  return written;
}

if (process.argv[1] === import.meta.filename) console.log((await renderInto()).join('\n'));

{
  "name": "harbor-site",
  "compatibility_date": "2026-10-01",
  "main": "worker.ts",
  "assets": {
    "directory": "./dist",
    "not_found_handling": "404-page",
    "html_handling": "auto-trailing-slash",
    "run_worker_first": ["/contact/send"]
  },
  "vars": { "CONTACT": "https://forms.harbor-tides.example/inbox" }
}

// Runs only for POST /contact/send (wrangler.jsonc, assets.run_worker_first); every other path is a file in dist/.
export default {
  async fetch(request: Request, env: { CONTACT: string }): Promise<Response> {
    if (request.method !== 'POST') return new Response('Method Not Allowed', { status: 405, headers: { allow: 'POST' } });
    const form = await request.formData();
    // Forward the form, field for field, to the Site's contact address.
    const sent = await fetch(env.CONTACT, { method: 'POST', body: form });
    if (!sent.ok) return new Response('The message was not sent. Try again.', { status: 502 });
    return Response.redirect(new URL('/contact/sent', request.url), 303);
  },
};