From cb562177516c62d3b22fa7c50ad5b337abbdb155 Mon Sep 17 00:00:00 2001
From: fosterwei <gongjian.sam@gmail.com>
Date: Mon, 12 Oct 2026 10:35:32 +0000
Subject: [PATCH] Give each compound with published doses its own calculator
 page

Nineteen new pages at /calculators/<compound>, plus an index, modelled on
the per-peptide calculators that peptidecalcs.com ranks with.

The arithmetic is identical for every peptide, so the arithmetic cannot
be what makes nineteen pages worth nineteen URLs. What differs is the
doses published studies of that compound actually used, and this site
already holds those as cited claims with an evidence tier on every
record. Each page puts that table under the calculator: what the paper
administered, in which species, with a link to the paper. No generic
calculator can do that, and no competitor cites a study for its numbers.

That same fact decides which compounds get a page. A compound qualifies
only if its record is written and reviewed and carries at least two
distinct quoted dose figures. Nineteen of thirty-four clear it. The rest
would be this page with the name changed, which is how a programmatic set
becomes index bloat, and the site has already noindexed seven pages on
that principle.

The pages keep the refusal the generic tool has: no body weight, no
condition, no returned dose. Showing what a trial gave is reporting,
which is what every record here does. Suggesting what a reader should
take would be advice, which none of them does. Pages where no human dose
exists say so in the lede rather than letting an animal figure imply one.

The calculator itself is the existing component, so the arithmetic has
one implementation and one set of tests.

test_calculators.mjs now covers every generated page, not just the three
generic tools: form present, output present, dose table non-empty, and
the script computing the known 5 mg / 2 mL / 250 mcg case. 36 assertions,
up from 17. Verified by stripping a form and by emptying a dose table,
each of which exits 1. Without this, one template change would silently
empty nineteen pages at once, which is exactly how the unit converter and
vial planner shipped as headings with no calculator.

The sitemap emits them explicitly, because they derive from the compounds
collection rather than being a collection of their own and nothing else
would have listed them.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 scripts/test_calculators.mjs       |  37 ++++++++++
 src/lib/calculators.ts             |  59 ++++++++++++++++
 src/pages/calculators/[slug].astro | 104 +++++++++++++++++++++++++++++
 src/pages/calculators/index.astro  |  67 +++++++++++++++++++
 src/pages/sitemap.xml.ts           |  12 +++-
 5 files changed, 278 insertions(+), 1 deletion(-)
 create mode 100644 src/lib/calculators.ts
 create mode 100644 src/pages/calculators/[slug].astro
 create mode 100644 src/pages/calculators/index.astro

diff --git a/scripts/test_calculators.mjs b/scripts/test_calculators.mjs
index c8675a8..c8204f1 100644
--- a/scripts/test_calculators.mjs
+++ b/scripts/test_calculators.mjs
@@ -84,6 +84,43 @@ check('vial: works without a volume',
 check('vial: empty input guarded',
   render(V, { 'v-mass': '', 'v-vol': 2, 'v-want': 250, 'v-freq': 7 }, 'v-out'), 'Enter a positive');
 
+// Every per-compound calculator runs the same script, so one broken render or a
+// template change that drops the form would take all of them out at once and
+// nothing else in the build would notice: a page with no <form> still builds,
+// still validates and still enters the sitemap. That is exactly how the unit
+// converter and vial planner shipped empty.
+const CALC_DIR = path.join(DIST, 'calculators');
+if (fs.existsSync(CALC_DIR)) {
+  const slugs = fs.readdirSync(CALC_DIR, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+  if (slugs.length === 0) fails.push('dist/calculators exists but contains no compound pages');
+  for (const slug of slugs) {
+    const file = path.join(CALC_DIR, slug, 'index.html');
+    if (!fs.existsSync(file)) { fails.push(`calculators/${slug}: not built`); continue; }
+    const html = fs.readFileSync(file, 'utf8');
+    if (!/<form\b/i.test(html)) { fails.push(`calculators/${slug}: no <form>`); continue; }
+    if (!/<output\b/i.test(html)) { fails.push(`calculators/${slug}: no <output>`); continue; }
+    // The dose table is the only reason this page exists rather than a link to
+    // the generic tool, so an empty one means the page should not have shipped.
+    const tableRows = (html.match(/<tbody>[\s\S]*?<\/tbody>/i) || [''])[0].match(/<tr>/gi) || [];
+    if (tableRows.length === 0) fails.push(`calculators/${slug}: dose table is empty`);
+    const m = html.match(/<script type="module">([\s\S]*?)<\/script>/i);
+    if (!m) { fails.push(`calculators/${slug}: no inline module script`); continue; }
+    const els = {};
+    for (const [id, v] of Object.entries({ 'r-mass': 5, 'r-vol': 2, 'r-want': 250, 'r-scale': 100 })) {
+      els[id] = { value: String(v), addEventListener() {} };
+    }
+    const out = { textContent: '' };
+    els['r-out'] = out;
+    globalThis.document = { getElementById: (id) => els[id] ?? null };
+    new Function(m[1])();
+    if (!out.textContent.includes('10 units on a U-100')) {
+      fails.push(`calculators/${slug}: calculator did not compute (got ${JSON.stringify(out.textContent)})`);
+    } else { pass++; }
+  }
+}
+
 if (fails.length) {
   console.error(`calculator tests: ${pass} passed, ${fails.length} FAILED\n`);
   for (const f of fails) console.error(`  ${f}\n`);
diff --git a/src/lib/calculators.ts b/src/lib/calculators.ts
new file mode 100644
index 0000000..a53df90
--- /dev/null
+++ b/src/lib/calculators.ts
@@ -0,0 +1,59 @@
+// Which compounds get their own calculator page, and the dose figures that make
+// each one different from the generic tool.
+//
+// A calculator per compound is only worth a URL if the page says something the
+// generic reconstitution calculator does not. The arithmetic is identical for
+// every peptide, so the arithmetic cannot be the differentiator. What differs is
+// the doses that published studies actually used, which this site already holds
+// as cited claims on each record.
+//
+// So a compound qualifies only when it carries at least two distinct quoted dose
+// figures, and only when its own record is finished and reviewed. Everything
+// else would be the same page with the name changed, which is how a programmatic
+// set turns into index bloat.
+import type { CollectionEntry } from 'astro:content';
+import { isIndexable } from './site';
+
+export const MIN_DISTINCT_DOSES = 2;
+
+const DOSE_FIGURE = /\d+(?:[.,]\d+)?\s*(?:mg|µg|mcg|ug|ng|IU|units?)\b/gi;
+
+export interface DoseRow {
+  value: string;
+  tier: string;
+  sourceIds: string[];
+  excerpt?: string;
+}
+
+/** Distinct dose figures quoted anywhere in the record's study_doses claims. */
+export function doseFigures(entry: CollectionEntry<'compounds'>): string[] {
+  const claims = ((entry.data as any).attributes?.study_doses ?? []) as any[];
+  const seen = new Set<string>();
+  for (const c of claims) {
+    for (const m of String(c.value ?? '').matchAll(DOSE_FIGURE)) {
+      seen.add(m[0].replace(/\s+/g, ' ').trim().toLowerCase());
+    }
+  }
+  return [...seen];
+}
+
+export function doseRows(entry: CollectionEntry<'compounds'>): DoseRow[] {
+  const claims = ((entry.data as any).attributes?.study_doses ?? []) as any[];
+  return claims.map((c) => ({
+    value: String(c.value ?? ''),
+    tier: String(c.evidence_label ?? 'editorial'),
+    sourceIds: (c.source_ids ?? []) as string[],
+    excerpt: c.source_excerpt,
+  }));
+}
+
+/** True when a compound earns its own calculator page. */
+export function qualifies(entry: CollectionEntry<'compounds'>): boolean {
+  return isIndexable(entry) && doseFigures(entry).length >= MIN_DISTINCT_DOSES;
+}
+
+/** Human-tier dose claims, which are the ones worth leading with. */
+export const HUMAN_TIERS = new Set(['approved-label', 'human-clinical-trial', 'observational-human']);
+export function humanDoseRows(entry: CollectionEntry<'compounds'>): DoseRow[] {
+  return doseRows(entry).filter((r) => HUMAN_TIERS.has(r.tier));
+}
diff --git a/src/pages/calculators/[slug].astro b/src/pages/calculators/[slug].astro
new file mode 100644
index 0000000..e191989
--- /dev/null
+++ b/src/pages/calculators/[slug].astro
@@ -0,0 +1,104 @@
+---
+// One calculator per compound. The arithmetic is the same on every one of these
+// pages, so the arithmetic is not what makes them different: the doses that
+// published studies of that compound actually used are, and those are quoted
+// from the record with their evidence tier and their source.
+//
+// Nothing here takes a body weight or a condition, and nothing returns a dose.
+// Showing what a trial administered is reporting, which is what the whole site
+// does; suggesting what a reader should take would be advice, which it never does.
+import Base from '../../layouts/Base.astro';
+import Calculators from '../../components/Calculators.astro';
+import Tier from '../../components/v2/Tier.astro';
+import { records } from '../../lib/collections';
+import { qualifies, doseRows, humanDoseRows, doseFigures } from '../../lib/calculators';
+import { isIndexable, TIER_LABEL } from '../../lib/site';
+
+export async function getStaticPaths() {
+  const compounds = await records('compounds');
+  return compounds.filter(qualifies).map((entry) => ({
+    params: { slug: entry.data.slug },
+    props: { entry },
+  }));
+}
+const { entry } = Astro.props;
+const d = entry.data as any;
+const name = d.preferred_name;
+const path = `/calculators/${d.slug}`;
+const rows = doseRows(entry);
+const human = humanDoseRows(entry);
+const figures = doseFigures(entry);
+const sources = new Map<string, any>((d.sources ?? []).map((s: any) => [s.id, s]));
+const routes = (d.attributes?.routes_studied ?? []) as any[];
+
+const title = `${name} Dosage Calculator: mg to mL and Syringe Units`;
+const description = `Convert ${name} vial mass and diluent into concentration, draw volume and syringe units, beside the doses published studies of ${name} actually used, each one cited.`;
+---
+<Base title={title} description={description} path={path} indexable={isIndexable(entry)} siteSuffix={false}>
+  <article class="prose-page">
+    <p class="eyebrow"><a href="/calculators">Calculators</a></p>
+    <h1>{name} dosage calculator</h1>
+    <p class="dek">
+      The arithmetic is the same for every peptide, so the part worth reading is underneath it:
+      the {human.length > 0 ? 'doses' : 'figures'} that published studies of {name} actually used,
+      quoted and tiered. This tool converts the numbers you enter. It does not suggest what to take.
+    </p>
+
+    <Calculators slug="reconstitution-calculator" />
+
+    <h2 id="studied">Doses in published studies of {name}</h2>
+    <p class="prose">
+      Every row is quoted from a paper in this compound's own source ledger and carries the kind of
+      evidence it came from. {human.length === 0
+        ? `None of them is a human dose: no study in this ledger administered ${name} to people at a stated dose. Animal figures are given per kilogram of animal and do not convert to a person by arithmetic.`
+        : `${human.length} of ${rows.length} come from human studies. The rest are animal or laboratory work, where a per-kilogram figure does not convert to a person.`}
+    </p>
+    <div class="card clip"><div class="tblwrap"><table class="tbl">
+      <caption>What studies of {name} administered, as published. Not a recommendation and not a range to pick from.</caption>
+      <thead><tr><th scope="col">Evidence</th><th scope="col">Dose as the paper states it</th><th scope="col">Source</th></tr></thead>
+      <tbody>
+        {rows.map((r) => (
+          <tr>
+            <td><Tier tier={r.tier} /></td>
+            <td>{r.value}</td>
+            <td>{r.sourceIds.map((id) => {
+              const s = sources.get(id);
+              return s?.url
+                ? <a href={s.url} rel="nofollow noopener">{id}</a>
+                : <span>{id}</span>;
+            })}</td>
+          </tr>
+        ))}
+      </tbody>
+    </table></div></div>
+
+    {routes.length > 0 && (
+      <Fragment>
+        <h2 id="routes">How {name} was given in those studies</h2>
+        <p class="prose">The route changes what a dose means. A figure from an intravenous infusion is not the same quantity as the same number given under the skin.</p>
+        <ul class="list">{routes.slice(0, 6).map((r: any) => <li>{r.value}</li>)}</ul>
+      </Fragment>
+    )}
+
+    <h2 id="refuses">What this calculator will not do</h2>
+    <p class="prose">
+      It will not take a body weight and return a milligram figure. That is a clinical decision, not
+      a division: it depends on why someone is taking something, what else they take, and what their
+      kidneys and liver are doing. None of that is knowable from a number typed into a box.
+    </p>
+    <p class="prose">
+      The table above is the published record, not a menu. {human.length === 0
+        ? `For ${name} in particular, there is no human dose in this ledger to copy even if you wanted to.`
+        : `A dose that appeared in a trial appeared under supervision, with monitoring, in people selected to be in that trial.`}
+      The full evidence, including what was measured and what went wrong, is on the <a href={`/compounds/${d.slug}`}>{name} record</a>.
+    </p>
+
+    <h2 id="other">Other calculators</h2>
+    <ul class="cards">
+      <li><a href="/tools/reconstitution-calculator">Generic reconstitution calculator</a><div class="sub">The same arithmetic, without a compound attached</div></li>
+      <li><a href="/tools/unit-converter">Unit converter</a><div class="sub">mg, mcg, ng and syringe units</div></li>
+      <li><a href="/tools/vial-planner">Vial planner</a><div class="sub">How many draws a vial yields and how long it lasts</div></li>
+      <li><a href="/calculators">All compound calculators</a><div class="sub">Every compound with published dose figures</div></li>
+    </ul>
+  </article>
+</Base>
diff --git a/src/pages/calculators/index.astro b/src/pages/calculators/index.astro
new file mode 100644
index 0000000..deec1c7
--- /dev/null
+++ b/src/pages/calculators/index.astro
@@ -0,0 +1,67 @@
+---
+import Base from '../../layouts/Base.astro';
+import Tier from '../../components/v2/Tier.astro';
+import { records } from '../../lib/collections';
+import { qualifies, doseFigures, humanDoseRows } from '../../lib/calculators';
+import { tools } from '../../lib/registry';
+
+const compounds = (await records('compounds'))
+  .filter(qualifies)
+  .sort((a, b) => a.data.preferred_name.localeCompare(b.data.preferred_name));
+const live = compounds.length > 0;
+---
+<Base
+  title="Peptide Dosage Calculators, One Per Compound"
+  description="A reconstitution calculator for each compound with published dose figures, showing the doses studies actually used beside the arithmetic, every one cited."
+  path="/calculators" indexable={live} siteSuffix={false}>
+  <article class="prose-page">
+    <p class="eyebrow">Directory</p>
+    <h1>Peptide dosage calculators</h1>
+    <p class="dek">
+      One calculator per compound, each showing the doses published studies of that compound
+      actually used, quoted with the kind of evidence they came from. The arithmetic is identical
+      everywhere; the evidence is not, and that is the part worth reading.
+    </p>
+
+    <h2 id="compounds">By compound</h2>
+    <p class="prose">
+      {compounds.length} compounds carry enough published dose figures to be worth their own page.
+      A compound with no cited dose does not get one, because it would be this page with a different
+      name on it.
+    </p>
+    <div class="card clip"><div class="tblwrap"><table class="tbl">
+      <caption>Each calculator does the same arithmetic. The difference is the evidence underneath it.</caption>
+      <thead><tr><th scope="col">Compound</th><th scope="col">Strongest dose evidence</th><th scope="col" class="num">Dose figures</th><th scope="col" class="num">Human doses</th></tr></thead>
+      <tbody>
+        {compounds.map((e) => {
+          const human = humanDoseRows(e);
+          return (
+            <tr>
+              <th scope="row" class="study"><a href={`/calculators/${e.data.slug}`}>{e.data.preferred_name}</a></th>
+              <td><Tier tier={e.data.evidence_tier} /></td>
+              <td class="num">{doseFigures(e).length}</td>
+              <td class="num">{human.length || '—'}</td>
+            </tr>
+          );
+        })}
+      </tbody>
+    </table></div></div>
+
+    <h2 id="generic">Without a compound attached</h2>
+    <ul class="cards">
+      {tools.map((t) => <li><a href={`/tools/${t.slug}`}>{t.name}</a><div class="sub">{t.computes}</div></li>)}
+    </ul>
+
+    <h2 id="refuses">What none of them will do</h2>
+    <p class="prose">
+      None takes a body weight, an age or a condition, and none returns a dose. They convert numbers
+      you already have into other numbers, by a formula printed above the inputs. Whether those
+      numbers are appropriate is a clinical question, and the <a href="/compounds">compound records</a>
+      are where the evidence for it lives.
+    </p>
+    <p class="prose">
+      A dose shown on these pages is one a study administered, reported as published. It is a record
+      of what happened in a trial, not a suggestion about what should happen to you.
+    </p>
+  </article>
+</Base>
diff --git a/src/pages/sitemap.xml.ts b/src/pages/sitemap.xml.ts
index 7ef087c..eca6bda 100644
--- a/src/pages/sitemap.xml.ts
+++ b/src/pages/sitemap.xml.ts
@@ -8,13 +8,14 @@
 import type { APIRoute } from 'astro';
 import { records } from '../lib/collections';
 import { isIndexable, lastmod } from '../lib/site';
+import { qualifies } from '../lib/calculators';
 
 const PREFIX = { compounds: '/compounds/', stacks: '/stacks/', comparisons: '/compare/', tools: '/tools/', posts: '/blog/' } as const;
 
 // Rendered pages that are not records. Kept here rather than derived, because
 // a page that should not be indexed must not be listed, and that is a decision
 // per page rather than a pattern.
-const STATIC = ['/', '/compounds', '/stacks', '/compare', '/tools', '/about', '/contact', '/privacy'];
+const STATIC = ['/', '/compounds', '/stacks', '/compare', '/tools', '/calculators', '/about', '/contact', '/privacy'];
 
 export const GET: APIRoute = async ({ site }) => {
   const urls: string[] = [];
@@ -29,6 +30,15 @@ export const GET: APIRoute = async ({ site }) => {
       urls.push(`<url><loc>${loc}</loc>${mod ? `<lastmod>${mod}</lastmod>` : ''}</url>`);
     }
   }
+  // Per-compound calculators are derived from the compounds collection rather
+  // than being a collection of their own, so nothing above emits them.
+  for (const entry of await records('compounds')) {
+    if (!qualifies(entry)) continue;
+    const loc = new URL(`/calculators/${entry.data.slug}`, site).toString();
+    const mod = lastmod(entry);
+    urls.push(`<url><loc>${loc}</loc>${mod ? `<lastmod>${mod}</lastmod>` : ''}</url>`);
+  }
+
   const xml = `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${urls.join('\n')}\n</urlset>\n`;
   return new Response(xml, { headers: { 'Content-Type': 'application/xml; charset=utf-8' } });
 };