edgepress 2026.9.3

package/src/worker.js

@@ -0,0 +1,139 @@
+const MAX_BACKEND_BODY_BYTES = 1_000_000;
+
+const json = (data, status = 200, headers = {}) => Response.json(data, {
+  status,
+  headers: { 'Cache-Control': 'no-store', ...headers }
+});
+
+async function readBoundedBody(body, limit) {
+  const reader = body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > limit) {
+        await reader.cancel();
+        return null;
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const result = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+
+async function noStore(response) {
+  const headers = new Headers(response.headers);
+  headers.set('Cache-Control', 'no-store');
+  headers.set('X-Content-Type-Options', 'nosniff');
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+
+function backendEndpoint(baseValue, requestUrl) {
+  let endpoint;
+  try { endpoint = new URL(baseValue); } catch { return null; }
+  const localHttp = endpoint.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(endpoint.hostname);
+  if ((!['https:', 'http:'].includes(endpoint.protocol) || (endpoint.protocol !== 'https:' && !localHttp)) ||
+      endpoint.username || endpoint.password || endpoint.search || endpoint.hash) return null;
+  const incoming = new URL(requestUrl);
+  const basePath = endpoint.pathname.replace(/\/+$/, '');
+  endpoint.pathname = basePath + incoming.pathname;
+  endpoint.search = incoming.search;
+  endpoint.hash = '';
+  return endpoint;
+}
+
+async function readApiBody(request) {
+  if (!request.body) return new Uint8Array();
+  const declaredLength = request.headers.get('content-length');
+  if (declaredLength !== null) {
+    const length = Number(declaredLength);
+    if (!Number.isSafeInteger(length) || length < 0) return { error: 'invalid_content_length', status: 400 };
+    if (length > MAX_BACKEND_BODY_BYTES) return { error: 'payload_too_large', status: 413 };
+  }
+  const body = await readBoundedBody(request.body, MAX_BACKEND_BODY_BYTES);
+  return body === null ? { error: 'payload_too_large', status: 413 } : body;
+}
+
+async function proxyConfiguredBackend(request, env, requestUrl) {
+  const endpoint = backendEndpoint(env.BACKEND_URL, requestUrl);
+  if (!endpoint || typeof env.BACKEND_TOKEN !== 'string' || !env.BACKEND_TOKEN.trim()) {
+    return json({ error: 'backend_unavailable' }, 503);
+  }
+  const body = await readApiBody(request);
+  if (body?.error) return json({ error: body.error }, body.status);
+  const headers = new Headers();
+  for (const name of ['accept', 'accept-language', 'content-type', 'if-match', 'if-none-match']) {
+    const value = request.headers.get(name);
+    if (value !== null) headers.set(name, value);
+  }
+  headers.set('authorization', 'Bearer ' + env.BACKEND_TOKEN);
+  const upstream = new Request(endpoint, {
+    method: request.method,
+    headers,
+    body: request.method === 'GET' ? undefined : body,
+    redirect: 'manual'
+  });
+  return await noStore(await fetch(upstream));
+}
+
+export default {
+  async fetch(request, env) {
+    const url = new URL(request.url);
+    if (url.pathname === '/api/health') {
+      if (request.method !== 'GET') {
+        return json({ error: 'method_not_allowed' }, 405, { Allow: 'GET' });
+      }
+      return json({ status: 'ok', service: 'edgepress' });
+    }
+
+    if (url.pathname.startsWith('/api/v1/')) {
+      if (!['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(request.method)) {
+        return json({ error: 'method_not_allowed' }, 405, { Allow: 'GET, POST, PUT, PATCH, DELETE' });
+      }
+      if (request.body && request.method === 'GET') return json({ error: 'body_not_allowed' }, 400);
+      if (env.BACKEND) {
+        const body = await readApiBody(request);
+        if (body?.error) return json({ error: body.error }, body.status);
+        const backendRequest = new Request(request.url, {
+          method: request.method,
+          headers: request.headers,
+          body: request.body ? body : undefined
+        });
+        return await noStore(await env.BACKEND.fetch(backendRequest));
+      }
+      if (env.BACKEND_URL || env.BACKEND_TOKEN) return await proxyConfiguredBackend(request, env, request.url);
+      return json({ error: 'backend_unavailable' }, 503);
+    }
+
+    if (url.pathname.startsWith('/api/')) return json({ error: 'not_found' }, 404);
+    const assetResponse = await env.ASSETS.fetch(request);
+    if (assetResponse.status !== 403 || /(?:^|\/)403\.html$/i.test(url.pathname)) return assetResponse;
+    const locale = url.pathname.match(/^\/([A-Za-z0-9-]+)\//)?.[1];
+    const errorPaths = [locale ? '/' + locale + '/403.html' : '', '/403.html'].filter(Boolean);
+    for (const path of [...new Set(errorPaths)]) {
+      const errorPage = await env.ASSETS.fetch(new Request(new URL(path, request.url)));
+      if (!errorPage.ok) continue;
+      const headers = new Headers(errorPage.headers);
+      headers.set('Cache-Control', 'no-store');
+      headers.delete('Content-Length');
+      return new Response(errorPage.body, { status: 403, headers });
+    }
+    return assetResponse;
+  }
+};

package/static/edgepress/language-select.js

@@ -0,0 +1,5 @@
+for (const select of document.querySelectorAll('[data-language-select]')) {
+  select.addEventListener('change', () => {
+    if (select.value) window.location.assign(select.value);
+  });
+}

package/static/edgepress/plugins/advertising/google-adsense.js

@@ -0,0 +1,26 @@
+export function load(integration) {
+  const slots = [...document.querySelectorAll('[data-edgepress-ad="' + CSS.escape(integration.id) + '"]')];
+  if (!slots.length) return;
+  if (!window.__edgepressAdsenseLoaded) {
+    window.__edgepressAdsenseLoaded = true;
+    const script = document.createElement('script');
+    script.async = true;
+    script.crossOrigin = 'anonymous';
+    script.src = 'https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=' + encodeURIComponent(integration.clientId);
+    script.dataset.edgepressProvider = 'google-adsense';
+    document.head.append(script);
+  }
+  for (const slot of slots) {
+    if (slot.dataset.loaded) continue;
+    slot.dataset.loaded = 'true';
+    const ad = document.createElement('ins');
+    ad.className = 'adsbygoogle';
+    ad.style.display = 'block';
+    ad.dataset.adClient = integration.clientId;
+    ad.dataset.adFormat = 'auto';
+    ad.dataset.fullWidthResponsive = 'true';
+    slot.append(ad);
+    window.adsbygoogle = window.adsbygoogle || [];
+    window.adsbygoogle.push({});
+  }
+}

package/static/edgepress/plugins/captcha/cloudflare-turnstile.js

@@ -0,0 +1,28 @@
+let loading;
+
+export async function load(integration) {
+  if (!document.querySelector('[data-edgepress-captcha="cloudflare-turnstile"]')) return;
+  await (loading ||= loadScript('https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit', 'cloudflare-turnstile'));
+  for (const element of document.querySelectorAll('[data-edgepress-captcha="cloudflare-turnstile"]')) {
+    if (element.dataset.rendered || !window.turnstile) continue;
+    element.dataset.rendered = 'true';
+    window.turnstile.render(element, {
+      sitekey: element.dataset.sitekey || integration.siteKey,
+      callback: (token) => element.dispatchEvent(new CustomEvent('edgepress:captcha-success', { bubbles: true, detail: { token } })),
+      'error-callback': () => { element.dataset.rendered = ''; }
+    });
+  }
+}
+
+function loadScript(src, name) {
+  return new Promise((resolve, reject) => {
+    if (window.turnstile) return resolve();
+    const script = document.createElement('script');
+    script.async = true;
+    script.src = src;
+    script.dataset.edgepressProvider = name;
+    script.onload = resolve;
+    script.onerror = () => reject(new Error('Could not load CAPTCHA provider'));
+    document.head.append(script);
+  });
+}

package/static/edgepress/plugins/captcha/google-recaptcha.js

@@ -0,0 +1,27 @@
+let loading;
+
+export async function load(integration) {
+  if (!document.querySelector('[data-edgepress-captcha="google-recaptcha"]')) return;
+  await (loading ||= loadScript('https://www.google.com/recaptcha/api.js?render=explicit', 'google-recaptcha'));
+  for (const element of document.querySelectorAll('[data-edgepress-captcha="google-recaptcha"]')) {
+    if (element.dataset.rendered || !window.grecaptcha?.render) continue;
+    element.dataset.rendered = 'true';
+    window.grecaptcha.render(element, {
+      sitekey: element.dataset.sitekey || integration.siteKey,
+      callback: (token) => element.dispatchEvent(new CustomEvent('edgepress:captcha-success', { bubbles: true, detail: { token } }))
+    });
+  }
+}
+
+function loadScript(src, name) {
+  return new Promise((resolve, reject) => {
+    if (window.grecaptcha?.render) return resolve();
+    const script = document.createElement('script');
+    script.async = true;
+    script.src = src;
+    script.dataset.edgepressProvider = name;
+    script.onload = resolve;
+    script.onerror = () => reject(new Error('Could not load CAPTCHA provider'));
+    document.head.append(script);
+  });
+}

package/static/edgepress/plugins/captcha/hcaptcha.js

@@ -0,0 +1,27 @@
+let loading;
+
+export async function load(integration) {
+  if (!document.querySelector('[data-edgepress-captcha="hcaptcha"]')) return;
+  await (loading ||= loadScript('https://js.hcaptcha.com/1/api.js?render=explicit', 'hcaptcha'));
+  for (const element of document.querySelectorAll('[data-edgepress-captcha="hcaptcha"]')) {
+    if (element.dataset.rendered || !window.hcaptcha?.render) continue;
+    element.dataset.rendered = 'true';
+    window.hcaptcha.render(element, {
+      sitekey: element.dataset.sitekey || integration.siteKey,
+      callback: (token) => element.dispatchEvent(new CustomEvent('edgepress:captcha-success', { bubbles: true, detail: { token } }))
+    });
+  }
+}
+
+function loadScript(src, name) {
+  return new Promise((resolve, reject) => {
+    if (window.hcaptcha?.render) return resolve();
+    const script = document.createElement('script');
+    script.async = true;
+    script.src = src;
+    script.dataset.edgepressProvider = name;
+    script.onload = resolve;
+    script.onerror = () => reject(new Error('Could not load CAPTCHA provider'));
+    document.head.append(script);
+  });
+}

package/static/edgepress/plugins/consent/manager.js

@@ -0,0 +1,180 @@
+const modules = {
+  'google-tag-manager': () => import('../tracking/google-tag-manager.js'),
+  'meta-pixel': () => import('../tracking/meta-pixel.js'),
+  'cloudflare-web-analytics': () => import('../statistics/cloudflare-web-analytics.js'),
+  'google-analytics': () => import('../statistics/google-analytics.js'),
+  'baidu-tongji': () => import('../statistics/baidu-tongji.js'),
+  'google-adsense': () => import('../advertising/google-adsense.js'),
+  'cloudflare-turnstile': () => import('../captcha/cloudflare-turnstile.js'),
+  'google-recaptcha': () => import('../captcha/google-recaptcha.js'),
+  'hcaptcha': () => import('../captcha/hcaptcha.js')
+};
+
+const storageKey = 'edgepress-privacy-choice';
+const configElement = document.getElementById('edgepress-privacy-config');
+if (configElement) {
+  try { initialize(JSON.parse(configElement.textContent)); }
+  catch { /* An invalid config does not enable any optional integration. */ }
+}
+
+function initialize(config) {
+  const privacy = config.privacy || {};
+  const integrations = Array.isArray(privacy.integrations) ? privacy.integrations : [];
+  const ui = config.ui || {};
+  const root = document.createElement('div');
+  root.className = 'privacy-manager';
+
+  const settingsButton = document.createElement('button');
+  settingsButton.type = 'button';
+  settingsButton.className = 'privacy-settings-button';
+  settingsButton.textContent = ui.privacySettings || 'Privacy settings';
+
+  const panel = document.createElement('section');
+  panel.className = 'privacy-panel';
+  panel.setAttribute('role', 'dialog');
+  panel.setAttribute('aria-modal', 'false');
+  panel.setAttribute('aria-labelledby', 'privacy-panel-title');
+  panel.lang = config.siteLanguage || document.documentElement.lang;
+  panel.hidden = true;
+
+  const heading = document.createElement('h2');
+  heading.id = 'privacy-panel-title';
+  heading.tabIndex = -1;
+  heading.textContent = ui.privacyNotice || 'Optional services';
+  const intro = document.createElement('p');
+  intro.textContent = ui.privacyIntro || 'Choose which optional services may load.';
+  const details = document.createElement('div');
+  details.className = 'privacy-details';
+  details.setAttribute('aria-label', ui.optionalServices || 'Optional services');
+  const actions = document.createElement('div');
+  actions.className = 'privacy-actions';
+  const close = makeButton(ui.closePrivacy || 'Close settings', 'privacy-close');
+
+  const accept = makeButton(ui.acceptOptional || 'Accept all', 'privacy-accept');
+  const reject = makeButton(ui.rejectOptional || 'Reject optional', 'privacy-reject');
+  const save = makeButton(ui.savePreferences || 'Save choices', 'privacy-save');
+  actions.append(accept, reject, save);
+  panel.append(close, heading, intro, details);
+  if (privacy.controller?.name || privacy.controller?.contact) {
+    const controller = document.createElement('p');
+    controller.className = 'privacy-controller';
+    controller.textContent = (ui.privacyController || 'Site operator') + ': ' + [privacy.controller.name, privacy.controller.contact].filter(Boolean).join(' · ');
+    panel.append(controller);
+  }
+  if (privacy.policyUrl) {
+    const policy = document.createElement('a');
+    policy.href = privacy.policyUrl;
+    policy.textContent = ui.privacyPolicy || 'Privacy policy';
+    policy.className = 'privacy-policy-link';
+    panel.append(policy);
+  }
+  panel.append(actions);
+  root.append(settingsButton, panel);
+  document.body.append(root);
+
+  const saved = readChoice(privacy);
+  const checkboxes = new Map();
+  for (const integration of integrations) {
+    const label = document.createElement('label');
+    label.className = 'privacy-service';
+    const checkbox = document.createElement('input');
+    checkbox.type = 'checkbox';
+    checkbox.value = integration.id;
+    checkbox.checked = saved?.allowed.includes(integration.id) || false;
+    const info = document.createElement('span');
+    const title = document.createElement('strong');
+    title.textContent = integration.provider;
+    const purpose = document.createElement('span');
+    purpose.textContent = (ui.servicePurpose || 'Purpose') + ': ' + integration.purpose;
+    info.append(title, document.createElement('br'), purpose);
+    if (integration.retention) {
+      const retention = document.createElement('span');
+      retention.textContent = ' · ' + (ui.serviceRetention || 'Retention') + ': ' + integration.retention;
+      info.append(retention);
+    }
+    label.append(checkbox, info);
+    details.append(label);
+    checkboxes.set(integration.id, checkbox);
+  }
+  if (!integrations.length) {
+    const empty = document.createElement('p');
+    empty.textContent = ui.noIntegrations || 'No optional services are configured.';
+    details.append(empty);
+    accept.disabled = true;
+    reject.disabled = true;
+    save.disabled = true;
+  }
+
+  settingsButton.addEventListener('click', () => {
+    panel.hidden = !panel.hidden;
+    if (!panel.hidden) heading.focus?.();
+  });
+  close.addEventListener('click', () => { panel.hidden = true; settingsButton.focus(); });
+  accept.addEventListener('click', () => saveChoice(integrations.map((item) => item.id)));
+  reject.addEventListener('click', () => saveChoice([]));
+  save.addEventListener('click', () => saveChoice([...checkboxes].filter(([, checkbox]) => checkbox.checked).map(([id]) => id)));
+
+  function saveChoice(allowed) {
+    const previous = readChoice(privacy);
+    const next = makeChoice(privacy, allowed);
+    persistChoice(next);
+    panel.hidden = true;
+    if (previous && previous.allowed.some((id) => !next.allowed.includes(id))) {
+      intro.textContent = ui.consentReload || 'Your choice was saved. Reloading to apply the updated settings.';
+      window.location.reload();
+      return;
+    }
+    activate(next.allowed);
+  }
+
+  if (saved) activate(saved.allowed);
+  else if (integrations.length) panel.hidden = false;
+
+  function makeButton(label, className) {
+    const button = document.createElement('button');
+    button.type = 'button';
+    button.className = className;
+    button.textContent = label;
+    return button;
+  }
+}
+
+function makeChoice(privacy, allowed) {
+  const expiresAt = Date.now() + Math.max(1, Math.min(730, privacy.consent?.expiresDays || 180)) * 86400000;
+  const fingerprint = JSON.stringify({ controller: privacy.controller, policyUrl: privacy.policyUrl, integrations: privacy.integrations });
+  return { version: privacy.consent?.version || '1', fingerprint, expiresAt, allowed: [...new Set(allowed)] };
+}
+
+function readChoice(privacy) {
+  try {
+    const saved = JSON.parse(localStorage.getItem(storageKey));
+    const fingerprint = JSON.stringify({ controller: privacy.controller, policyUrl: privacy.policyUrl, integrations: privacy.integrations });
+    if (!saved || saved.version !== (privacy.consent?.version || '1') || saved.fingerprint !== fingerprint || saved.expiresAt <= Date.now() || !Array.isArray(saved.allowed)) {
+      localStorage.removeItem(storageKey);
+      return null;
+    }
+    const validIds = new Set((privacy.integrations || []).map((item) => item.id));
+    saved.allowed = saved.allowed.filter((id) => validIds.has(id));
+    return saved;
+  } catch { return null; }
+}
+
+function persistChoice(choice) {
+  try { localStorage.setItem(storageKey, JSON.stringify(choice)); } catch { /* Session choice still applies in memory. */ }
+}
+
+async function activate(allowed) {
+  const config = JSON.parse(document.getElementById('edgepress-privacy-config').textContent);
+  const permitted = new Set(allowed);
+  for (const integration of config.privacy.integrations || []) {
+    if (!permitted.has(integration.id)) continue;
+    const loader = modules[integration.provider];
+    if (!loader) continue;
+    try {
+      const provider = await loader();
+      await provider.load(integration);
+    } catch (error) {
+      console.error('EdgePress optional integration failed to load:', integration.provider, error);
+    }
+  }
+}

package/static/edgepress/plugins/statistics/baidu-tongji.js

@@ -0,0 +1,8 @@
+export function load(integration) {
+  if (document.querySelector('script[data-edgepress-provider="baidu-tongji"]')) return;
+  const script = document.createElement('script');
+  script.async = true;
+  script.src = 'https://hm.baidu.com/hm.js?' + encodeURIComponent(integration.siteId);
+  script.dataset.edgepressProvider = 'baidu-tongji';
+  document.head.append(script);
+}

package/static/edgepress/plugins/statistics/cloudflare-web-analytics.js

@@ -0,0 +1,9 @@
+export function load(integration) {
+  if (document.querySelector('script[data-edgepress-provider="cloudflare-web-analytics"]')) return;
+  const script = document.createElement('script');
+  script.async = true;
+  script.src = 'https://static.cloudflareinsights.com/beacon.min.js';
+  script.dataset.cfBeacon = JSON.stringify({ token: integration.token });
+  script.dataset.edgepressProvider = 'cloudflare-web-analytics';
+  document.head.append(script);
+}

package/static/edgepress/plugins/statistics/google-analytics.js

@@ -0,0 +1,13 @@
+export function load(integration) {
+  if (window.__edgepressGaLoaded) return;
+  window.__edgepressGaLoaded = true;
+  window.dataLayer = window.dataLayer || [];
+  window.gtag = window.gtag || function gtag() { window.dataLayer.push(arguments); };
+  window.gtag('js', new Date());
+  window.gtag('config', integration.measurementId, { anonymize_ip: true });
+  const script = document.createElement('script');
+  script.async = true;
+  script.src = 'https://www.googletagmanager.com/gtag/js?id=' + encodeURIComponent(integration.measurementId);
+  script.dataset.edgepressProvider = 'google-analytics';
+  document.head.append(script);
+}

package/static/edgepress/plugins/tracking/google-tag-manager.js

@@ -0,0 +1,10 @@
+export function load(service) {
+  if (document.querySelector('script[data-edgepress-provider="google-tag-manager"]')) return;
+  window.dataLayer = window.dataLayer || [];
+  window.dataLayer.push({ 'gtm.start': Date.now(), event: 'gtm.js' });
+  const script = document.createElement('script');
+  script.async = true;
+  script.src = 'https://www.googletagmanager.com/gtm.js?id=' + encodeURIComponent(service.containerId);
+  script.dataset.edgepressProvider = 'google-tag-manager';
+  document.head.append(script);
+}

package/static/edgepress/plugins/tracking/meta-pixel.js

@@ -0,0 +1,18 @@
+export function load(service) {
+  if (window.__edgepressMetaPixelLoaded) return;
+  window.__edgepressMetaPixelLoaded = true;
+  window.fbq = window.fbq || function fbq() {
+    if (window.fbq.callMethod) window.fbq.callMethod.apply(window.fbq, arguments);
+    else window.fbq.queue.push(arguments);
+  };
+  window.fbq.queue = window.fbq.queue || [];
+  window.fbq.loaded = true;
+  window.fbq.version = '2.0';
+  window.fbq('init', service.pixelId);
+  window.fbq('track', 'PageView');
+  const script = document.createElement('script');
+  script.async = true;
+  script.src = 'https://connect.facebook.net/en_US/fbevents.js';
+  script.dataset.edgepressProvider = 'meta-pixel';
+  document.head.append(script);
+}

package/static/edgepress/search.js

@@ -0,0 +1,84 @@
+const form = document.querySelector('[data-edgepress-search]');
+
+if (form) {
+  const input = form.querySelector('input[type="search"]');
+  const status = document.getElementById('edgepress-search-status');
+  const results = document.getElementById('edgepress-search-results');
+  const language = document.documentElement.lang.toLowerCase();
+  const chinese = language.startsWith('zh');
+  let indexPromise;
+  let timer;
+
+  function loadIndex() {
+    if (!indexPromise) {
+      indexPromise = fetch(form.dataset.index, { credentials: 'same-origin' }).then((response) => {
+        if (!response.ok) throw new Error('Search index request failed');
+        return response.json();
+      }).then((items) => items.filter((item) => item.type === 'post'));
+    }
+    return indexPromise;
+  }
+
+  function resultCard(item) {
+    const entry = document.createElement('li');
+    const article = document.createElement('article');
+    const heading = document.createElement('h2');
+    const link = document.createElement('a');
+    link.href = item.url;
+    link.textContent = item.title;
+    heading.append(link);
+    article.append(heading);
+    if (item.date) {
+      const time = document.createElement('time');
+      time.dateTime = item.date;
+      time.textContent = new Intl.DateTimeFormat(language, { dateStyle: 'long', timeZone: 'UTC' }).format(new Date(item.date));
+      article.append(time);
+    }
+    const summary = document.createElement('p');
+    summary.textContent = item.summary || '';
+    article.append(summary);
+    entry.append(article);
+    return entry;
+  }
+
+  async function search(value) {
+    const query = value.normalize('NFKC').toLocaleLowerCase(language).trim();
+    results.replaceChildren();
+    if (!query) {
+      status.textContent = chinese ? '输入搜索词以查找文章。' : 'Enter a search term to find articles.';
+      return;
+    }
+    status.textContent = chinese ? '正在搜索文章…' : 'Searching articles…';
+    try {
+      const terms = query.split(/\s+/u).filter(Boolean);
+      const items = await loadIndex();
+      const matches = items.filter((item) => {
+        const text = (item.title + ' ' + (item.content || '') + ' ' + (item.summary || ''))
+          .normalize('NFKC').toLocaleLowerCase(language);
+        return terms.every((term) => text.includes(term));
+      });
+      for (const item of matches) results.append(resultCard(item));
+      status.textContent = matches.length
+        ? (chinese ? `找到 ${matches.length} 篇文章。` : `${matches.length} matching article${matches.length === 1 ? '' : 's'}.`)
+        : (chinese ? '没有找到匹配的文章。' : 'No matching articles.');
+    } catch {
+      status.textContent = chinese ? '无法载入本地文章索引，请稍后重试。' : 'The local article index could not be loaded. Try again later.';
+    }
+  }
+
+  form.addEventListener('submit', (event) => {
+    event.preventDefault();
+    clearTimeout(timer);
+    void search(input.value);
+  });
+  input.addEventListener('input', () => {
+    clearTimeout(timer);
+    timer = setTimeout(() => void search(input.value), 140);
+  });
+
+  const initialQuery = new URLSearchParams(window.location.search).get('q');
+  if (initialQuery) {
+    input.value = initialQuery;
+    void search(initialQuery);
+  }
+}

package/static/edgepress-markdown-guide.svg

@@ -0,0 +1,21 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 960 320" role="img" aria-labelledby="title desc">
+  <title id="title">EdgePress Markdown publishing flow</title>
+  <desc id="desc">Markdown source passes through rendering and HTML sanitization to a published post.</desc>
+  <rect width="960" height="320" rx="24" fill="#f5f3ee"/>
+  <g font-family="system-ui, sans-serif" text-anchor="middle" fill="#24352d">
+    <rect x="44" y="86" width="230" height="148" rx="18" fill="#fff" stroke="#b8c6bc" stroke-width="3"/>
+    <text x="159" y="139" font-size="23" font-weight="700">Markdown source</text>
+    <text x="159" y="181" font-size="17">content/posts/en.md</text>
+    <text x="159" y="209" font-size="17">headings · lists · links</text>
+    <path d="M292 160h78m-16-16 16 16-16 16" fill="none" stroke="#426b57" stroke-width="5" stroke-linecap="round" stroke-linejoin="round"/>
+    <rect x="382" y="86" width="230" height="148" rx="18" fill="#e3ece5" stroke="#9db4a4" stroke-width="3"/>
+    <text x="497" y="139" font-size="23" font-weight="700">EdgePress build</text>
+    <text x="497" y="181" font-size="17">CommonMark + GFM</text>
+    <text x="497" y="209" font-size="17">safe HTML output</text>
+    <path d="M630 160h78m-16-16 16 16-16 16" fill="none" stroke="#426b57" stroke-width="5" stroke-linecap="round" stroke-linejoin="round"/>
+    <rect x="720" y="86" width="196" height="148" rx="18" fill="#fff" stroke="#b8c6bc" stroke-width="3"/>
+    <text x="818" y="139" font-size="23" font-weight="700">Published post</text>
+    <text x="818" y="181" font-size="17">accessible HTML</text>
+    <text x="818" y="209" font-size="17">static site output</text>
+  </g>
+</svg>

package/templates/gitignore

@@ -0,0 +1,6 @@
+node_modules/
+dist/
+.edgepress/
+.wrangler/
+.dev.vars
+*.tgz

package/templates/site-readme.md

@@ -0,0 +1,20 @@
+# My EdgePress site
+
+Static site source built with EdgePress. Use Node.js 22.12 or newer.
+
+## Start locally
+
+    npm install
+    edgepress server
+
+Edit localized pages in `content/pages/` and Markdown posts in `content/posts/`. Choose a shared layout with `edgepress theme list` and `edgepress theme use <name>`.
+
+## Deploy to Cloudflare Workers
+
+Push this source repository to GitHub, then connect the repository to Cloudflare Workers Builds. The `build` and `deploy` scripts in `package.json` generate the static files and deploy the Worker. Set a unique Worker name in `wrangler.jsonc` first.
+
+For a local deployment, run `npx wrangler login`, then `edgepress deploy`.
+
+## Use another static web server
+
+Run `edgepress generate` and upload the contents of `dist/` to the server document root. OpenResty and Nginx can serve the generated directories as static files. Worker API routes and service bindings need a Worker or an equivalent server-side route.