@jeffreyjyz/mpc 0.1.2 → 0.1.4

package/README.md

@@ -31,6 +31,7 @@ mpc --help
 mpc                                   # oc-go Go vs CommandCode GOAT, default workload
 mpc --cc-plan pro                     # compare against CommandCode Pro
 mpc --cc-plan go                      # ...or the $1 Go plan
+mpc --oc-plan go-plus                 # OpenCode Go Plus ($40) instead of Go ($10)
 mpc --minimal                         # model + req/mo both sides + win + val
 mpc --medium                          # allowances + the rate views per side
 mpc --detail                          # every column, untrimmed (for copy/paste or agents)
@@ -88,6 +89,7 @@ Every flag persists. `mpc` reads `~/.config/mpc/config.json` (or `$XDG_CONFIG_HO
 ```json
 {
   "ccPlan": "goat",
+  "ocPlan": "go",
   "columns": ["model", "oc-per1k", "cc-per1k", "val"],
   "presets": { "cheap": ["model", "oc-per1k", "cc-per1k", "cost"] },
   "metric": "val",
@@ -115,6 +117,7 @@ Relative paths resolve against the config file's directory. A plugin is a `.json
 | Flag | Default | Meaning |
 | --- | --- | --- |
 | `--cc-plan <id>` | `goat` | CommandCode plan: `go`, `goat`, `pro`, `max10`, `max20` |
+| `--oc-plan <id>` | `go` | OpenCode Go plan: `go`, `go-plus` (same token rates, higher per-model limits) |
 | `--in <n>` | `800` | fixed input tokens per request |
 | `--cache <n>` | `50000` | fixed cache-read tokens per request |
 | `--out <n>` | `200` | fixed output tokens per request |
@@ -136,7 +139,6 @@ Relative paths resolve against the config file's directory. A plugin is a `.json
 | `--bench-name <label>` | source | footer label for the ability source |
 | `--aa-key <key>` | `AA_API_KEY` | Artificial Analysis API key |
 | `--no-fallback` | off | skip filling ability misses from the other sources |
-| `--refresh` | off | ignore the `aa-web` cache |
 | `--no-ability` | off | hide `ability` and `VAL` |
 | `--preset <name>` | — | named column set from `presets` in config |
 | `--val-weights <a,b,c,d,e>` | see above | VAL weights (ability, tps, volume, cache, output) |
@@ -166,7 +168,7 @@ Relative paths resolve against the config file's directory. A plugin is a `.json
 | --- | --- |
 | `cmduse plans --json` | CommandCode plan price, credits, 5h/weekly windows |
 | `commandcode.ai/docs/plans/{goat,pro,max}` | per-model credits + token rates |
-| `opencode.ai/docs/go/` | oc-go per-model monthly limit + token rates |
+| `opencode.ai/v2/docs/console/go/` | oc-go per-model monthly limit (per Go plan) + shared token rates |
 | `opencode.ai/zen/go/v1/models` | oc-go live model list (`--check` drift) |
 
 ## Reading the table
@@ -240,17 +242,18 @@ VAL = 100 * (0.35*ability + 0.10*tps + 0.25*volume + 0.15*cache + 0.15*output)
 | `cc` | CommandCode's `Intelligence` column | every matched model |
 | `file:<path>` / `url:<url>` | your JSON, `{ "model": score }` or `[{ model, score }]` | whatever you supply |
 
-The default is `aa` when an AA key is available (`AA_API_KEY` or `--aa-key`), otherwise `cc`; an explicit `--bench` always wins. After the lead source, misses are filled from the same benchmark's keyless page scrape (`aa-web`) and then from CommandCode, the last resort — `--no-fallback` disables the fills. Because CC's `Intelligence` column and AA publish the same index, a `cc`-led run asks AA only when it still lacks throughput (CC's plan pages no longer publish `Tok/s`). The `aa-web` result is cached under `$XDG_CACHE_HOME/mpc/` (or `~/.cache/mpc/`) for 7 days; `--refresh` busts it.
+The default is `aa` when an AA key is available (`AA_API_KEY` or `--aa-key`), otherwise `cc`; an explicit `--bench` always wins. After the lead source, misses are filled from the same benchmark's keyless page scrape (`aa-web`) and then from CommandCode, the last resort — `--no-fallback` disables the fills. Because CC's `Intelligence` column and AA publish the same index, a `cc`-led run asks AA only when it still lacks throughput (CC's plan pages no longer publish `Tok/s`). Everything is fetched live, every run — **`mpc` writes no cache**: `aa-web` reads the index and speed straight out of the models page's embedded React Server Components payload, so a source that is down costs only the columns it alone supplies, never a stale value.
 
 ## Model matching
 
-Names from the two catalogs are collapsed onto one canonical key (lowercase, vendor prefix stripped, punctuation removed, parenthetical qualifiers dropped), with a small alias table for branding differences (`Tencent Hy3` ↔ `hy3`, `…Vision (exp)` ↔ `…vision-exp`). Models present on only one side still appear; the other column shows `—`.
+Names from the two catalogs are collapsed onto one canonical key (lowercase, vendor prefix stripped, punctuation removed, parenthetical qualifiers dropped), with a small alias table for branding differences (`Tencent Hy3` ↔ `hy3`, `…Vision (exp)` ↔ `…vision-exp`). A trailing `Free` marker is not a branding alias — it is stripped by a generic rule, since the docs append it to every free model. Models present on only one side still appear; the other column shows `—`.
 
 ## Notes and limits
 
 - CommandCode plans are read from their docs pages: `goat`, `pro` and the Max plans list explicit per-model credits; the **Go** ($1) plan publishes only a rate list, so every model draws on the plan's whole $10 credit pool.
 - Models CommandCode lists with rates but no explicit credits row (the "older models also available" set) use the documented standard allowance ($20 on GOAT, $30 on Pro).
-- OpenCode Go has no shared credit pool; each model carries its own monthly limit, so the plan's "credits" figure is the sum of those limits (an upper bound, not a pool).
+- OpenCode sells two Go plans — **Go** ($10/mo) and **Go Plus** ($40/mo) — with identical token rates but different per-model monthly limits; `--oc-plan` picks which. Go has no shared credit pool, so the plan's "credits" figure is the sum of the per-model limits (an upper bound, not a pool).
+- OpenCode Go's free models (`LongCat 2.5 Preview Free`, `Step 5 Preview Free`) publish an `Unlimited` monthly limit instead of a $ figure. They are included as free entries — `$0` rates, unbounded `req/mo` — and, since their allowance is meaningless at zero cost, they add nothing to the plan's summed credits. Their docs-only `… Free` suffix is stripped by that generic rule (the marker is systematic, never a per-model alias), so a variant merges onto the model's one row instead of appearing twice.
 - `$/1K` and `req/$` are plan-relative: they divide by the plan's own price, so a cheaper subscription can post a lower per-request cost while buying fewer requests. Compare `req/mo` for volume and `$/1K` for the effective rate.
 - Values reflect the docs at fetch time; active deals are picked up automatically.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jeffreyjyz/mpc",
-	"version": "0.1.2",
+	"version": "0.1.4",
 	"description": "Compare model pricing across opencode Go and Command Code plans",
 	"license": "MIT",
 	"type": "module",

package/src/cli/flow/collect.ts

@@ -21,7 +21,7 @@ function scoreConfig(options: Options): ScoreConfig {
 
 export async function collect(options: Options) {
 	const [ocEntries, ccEntries, ccPlanInfo, shape] = await Promise.all([
-		loadOcGoCatalog(options.peak),
+		loadOcGoCatalog(options.ocPlan, options.peak),
 		loadCcCatalog(options.ccPlan),
 		loadCcPlan(options.ccPlan),
 		loadShapes(options.shape, options.since),
@@ -50,9 +50,8 @@ export async function collect(options: Options) {
 				key: options.aaKey,
 				keys,
 				fallback: !options.noFallback,
-				refresh: options.refresh,
 			});
-	const ocPlanInfo = ocGoPlan(ocEntries);
+	const ocPlanInfo = ocGoPlan(ocEntries, options.ocPlan);
 	const rows = buildRows(
 		ocEntries,
 		ccEntries,

package/src/cli/options.ts

@@ -8,6 +8,7 @@ export type Format = "table" | "json" | "csv" | "md";
 
 export interface Options {
 	ccPlan: string;
+	ocPlan: string;
 	workload: Workload;
 	/** `off` (the default), `measured`, or a path to a saved reqshape JSON. */
 	shape: string;
@@ -36,7 +37,6 @@ export interface Options {
 	benchName?: string;
 	aaKey?: string;
 	noFallback: boolean;
-	refresh: boolean;
 	noAbility: boolean;
 	peak: boolean;
 	asc: boolean;

package/src/cli/parse/cac.ts

@@ -10,6 +10,7 @@ export function parseFlags(argv: string[]): Bag {
 		"--cc-plan <id>",
 		"CommandCode plan: go, goat, pro, max10, max20",
 	)
+		.option("--oc-plan <id>", "OpenCode Go plan: go, go-plus")
 		.option("--in <n>", "input tokens per request")
 		.option("--cache <n>", "cache-read tokens per request")
 		.option("--out <n>", "output tokens per request")
@@ -66,7 +67,6 @@ export function parseFlags(argv: string[]): Bag {
 		.option("--bench-name <label>", "footer label for the source")
 		.option("--aa-key <key>", "Artificial Analysis key (else AA_API_KEY)")
 		.option("--no-fallback", "do not fill misses from other sources")
-		.option("--refresh", "ignore the aa-web cache")
 		.option("--no-ability", "hide ability and VAL")
 		.option("--peak", "peak-rate rows (OpenCode DeepSeek)")
 		.option("--asc", "flip the default sort direction")

package/src/cli/parse/map.ts

@@ -40,6 +40,7 @@ export function toOptions(bag: Bag): Options {
 	const window = numbers(bag, "window");
 	return {
 		ccPlan: String(pick(bag, "ccPlan")),
+		ocPlan: String(pick(bag, "ocPlan")),
 		workload: {
 			input: int("in", pick(bag, "in")),
 			cacheRead: int("cache", pick(bag, "cache")),
@@ -92,7 +93,6 @@ export function toOptions(bag: Bag): Options {
 			bag.benchName === undefined ? undefined : String(bag.benchName),
 		aaKey: bag.aaKey === undefined ? undefined : String(bag.aaKey),
 		noFallback: bag.fallback === false,
-		refresh: bag.refresh === true,
 		noAbility: bag.ability === false,
 		peak: bag.peak === true,
 		asc: bag.asc === true,

package/src/cli/run.ts

@@ -4,6 +4,7 @@ import { loadUsage } from "#~/data/usage/index.ts";
 import { renderUsage } from "#~/view/layout/usage.ts";
 import {
 	fitColumns,
+	planTitle,
 	renderCsv,
 	renderJson,
 	renderMarkdown,
@@ -145,7 +146,7 @@ export async function run(argv: string[]): Promise<number> {
 		: { ids: requested, dropped: [] as string[] };
 	renderText(result, meta, fitted.ids, fitted.dropped);
 	console.log(
-		`\n${result.length} models · OpenCode Go vs CommandCode ${ccPlanInfo.label} · ${ocEntries.length} OpenCode / ${ccEntries.length} CommandCode entries`,
+		`\n${result.length} models · ${planTitle(ocPlanInfo)} vs CommandCode ${ccPlanInfo.label} · ${ocEntries.length} OpenCode / ${ccEntries.length} CommandCode entries`,
 	);
 	return 0;
 }

package/src/constants/cli.ts

@@ -1,5 +1,6 @@
 import type { Format, Metric } from "#~/cli/options.ts";
 import { SHAPE_AUTO } from "#~/constants/shape.ts";
+import { DEFAULT_OC_PLAN } from "#~/constants/sources.ts";
 import {
 	DETAIL_COLUMNS,
 	MEDIUM_COLUMNS,
@@ -23,6 +24,7 @@ export const BENCH_DEFAULT = { keyed: "aa", keyless: "cc" } as const;
 /** The raw CLI bag defaults, before config/plugin layering. */
 export const ARG_DEFAULTS = {
 	ccPlan: "goat",
+	ocPlan: DEFAULT_OC_PLAN,
 	in: 800,
 	cache: 50_000,
 	out: 200,
@@ -49,6 +51,7 @@ export const INTERNAL = new Set(["--", "help", "h", "version", "v"]);
 
 export const KNOWN = new Set([
 	"ccPlan",
+	"ocPlan",
 	"in",
 	"cache",
 	"out",
@@ -66,7 +69,6 @@ export const KNOWN = new Set([
 	"benchName",
 	"aaKey",
 	"fallback",
-	"refresh",
 	"ability",
 	"peak",
 	"asc",
@@ -110,6 +112,7 @@ export const KNOWN = new Set([
  */
 export const VALUED = new Set([
 	"ccPlan",
+	"ocPlan",
 	"in",
 	"cache",
 	"out",

package/src/constants/data.ts

@@ -23,6 +23,9 @@ export const ALIASES: Record<string, string> = {
 	qwen38flashnext: "qwen38flash",
 };
 
+/** The monthly-limit cell of a free model: "Unlimited", often with a note. */
+export const UNLIMITED = /\bunlimited\b/i;
+
 /** The chip text of a promotion: "-40%", "-98%", "Free", "2x usage". */
 export const BADGE = /^-?\d+(?:\.\d+)?%$|^free$|^\d+x(?:\s+usage)?$/i;
 

package/src/constants/sources.ts

@@ -51,9 +51,33 @@ export const CC_PLANS: Record<string, CcPlanDef> = {
 	},
 };
 
-export const DOC_URL = "https://opencode.ai/docs/go/";
+/** One OpenCode Go plan: a docs tab label and its monthly subscription price. */
+interface OcPlanDef {
+	/** Docs tab label; the discriminator between the two plans' tables. */
+	label: string;
+	/** Subscription USD per month. */
+	price: number;
+}
+
+const GO_PRICE_PER_MONTH = 10;
+const GO_PLUS_PRICE_PER_MONTH = 40;
+
+/**
+ * OpenCode Go has two plans sharing one token price list but granting each
+ * model a different monthly limit. The docs put each plan's allowance table in
+ * a `<TabItem label="…">`; the tab label is what tells the otherwise identical
+ * tables apart, so it doubles as the plan's identity here.
+ */
+export const OC_PLANS: Record<string, OcPlanDef> = {
+	go: { label: "Go", price: GO_PRICE_PER_MONTH },
+	"go-plus": { label: "Go Plus", price: GO_PLUS_PRICE_PER_MONTH },
+};
+
+/** The Go plan used when `--oc-plan` is not given. */
+export const DEFAULT_OC_PLAN = "go";
+
+export const DOC_URL = "https://opencode.ai/v2/docs/console/go/";
 export const OC_MODELS_URL = "https://opencode.ai/zen/go/v1/models";
-export const PRICE_PER_MONTH = 10;
 
 export const API_URL = "https://artificialanalysis.ai/api/v2/data/llms/models";
 export const AA_MODELS_URL = "https://artificialanalysis.ai/models";
@@ -64,6 +88,3 @@ export const PAGES = [
 	"https://commandcode.ai/docs/plans/pro",
 ];
 export const TPS_HEADER = /tok\s*\/?\s*s|tokens?\s*per\s*sec/i;
-
-/** How long a cached benchmark result is considered fresh, in milliseconds. */
-export const CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;

package/src/data/bench/index.ts

@@ -1,6 +1,6 @@
+import { loadAaWeb } from "#~/data/sources/aa/web.ts";
 import { loadCc } from "./cc.ts";
-import { loadAaFallback, loadAaWeb, resolvePrimary } from "./resolve.ts";
-import { fillFromCache, readAbilityCache, writeAbilityCache } from "./store.ts";
+import { loadAaFallback, resolvePrimary } from "./resolve.ts";
 import type { AbilityOptions, AbilityResult } from "./types.ts";
 
 export type {
@@ -32,65 +32,31 @@ function prune(map: Map<string, number>, keys?: Set<string>): void {
 }
 
 /**
- * Load benchmark scores. The chosen source leads; unless --no-fallback, any
- * model it misses is filled from the other sources so a model scored anywhere
- * shows a value. The whole result is cached: a source that is down — or a page
- * that silently dropped a column — falls back to the last good run rather than
- * blanking a column.
+ * Load benchmark scores, live, every run. The chosen source leads; unless
+ * --no-fallback, any model it misses is filled from the other sources so a
+ * model scored anywhere shows a value. Nothing is cached: a source that is down
+ * costs the columns it alone supplies, never a stale value.
  */
 export async function loadAbility(
 	opts: AbilityOptions,
 ): Promise<AbilityResult> {
-	let live: AbilityResult;
-	try {
-		live = await loadLiveAbility(opts);
-	} catch (error) {
-		// Refresh must not strand the caller: an outage still has the cache.
-		const cached = await readAbilityCache(false);
-		if (!cached) throw error;
-		return {
-			...cached,
-			label: "cached (benchmark sources unavailable)",
-			note:
-				error instanceof Error
-					? error.message.slice(0, 120)
-					: undefined,
-		};
-	}
-	const cached = await readAbilityCache(Boolean(opts.refresh));
-	const filled = cached ? fillFromCache(live, cached) : 0;
-	await writeAbilityCache(live);
-	if (filled === 0) return live;
-	return {
-		...live,
-		note: [live.note, `${filled} values from the last cached run`]
-			.filter(Boolean)
-			.join(", "),
-	};
-}
-
-async function loadLiveAbility(opts: AbilityOptions): Promise<AbilityResult> {
 	const primary = await resolvePrimary(opts);
 	// CommandCode and Artificial Analysis publish the same intelligence index, so
 	// a CC primary normally needs no second round-trip. That premise only covered
 	// the index though: CC's plan pages dropped their `Tok/s` column (Sep 2026),
-	// so a CC primary with no speed values has to ask AA after all — otherwise
-	// every model reports speed null and the consumers drop the row.
+	// so a CC primary with no speed values has to ask AA after all.
 	const needsSpeed = primary.data.tps.size === 0;
 	if (!opts.fallback || (primary.scheme === "cc" && !needsSpeed)) {
 		return { ...primary.data, label: primary.label };
 	}
 
 	const fills: string[] = [];
-	// The API leads, so give the same benchmark's keyless page scrape a second
-	// look (cached, free when warm) before the cross-source fallback.
+	// The API leads, so give the same benchmark's keyless page scrape a second look.
 	if (primary.scheme === "aa") {
-		const web = await loadAaWeb(opts);
-		const added = merge(
-			primary.data.intelligence,
-			web.intelligence,
-			opts.keys,
-		);
+		const web = await loadAaWeb();
+		const added =
+			merge(primary.data.intelligence, web.intelligence, opts.keys) +
+			merge(primary.data.tps, web.tps, opts.keys);
 		if (added > 0) fills.push(`${added} values from AA web scrape`);
 	}
 	{

package/src/data/bench/resolve.ts

@@ -1,12 +1,44 @@
+import { fetchText } from "#~/data/scrape/index.ts";
 import { loadAaApi } from "#~/data/sources/aa/api.ts";
+import { loadAaWeb } from "#~/data/sources/aa/web.ts";
+import { normalizeKey } from "#~/keys.ts";
 import { loadCc } from "./cc.ts";
-import { loadAaWebCached, loadFile, loadUrl } from "./store.ts";
-import {
-	type AbilityOptions,
-	type BenchData,
-	emptyData,
-	type Resolved,
-} from "./types.ts";
+import type { AbilityOptions, BenchData, Resolved } from "./types.ts";
+
+/** Parse `{ model: score }` or `[{ model|name, score|value }]` JSON. */
+function parseJsonScores(text: string): Map<string, number> {
+	const body = JSON.parse(text) as unknown;
+	const scores = new Map<string, number>();
+	const add = (name: unknown, score: unknown): void => {
+		const key = typeof name === "string" ? normalizeKey(name) : "";
+		const value = Number(score);
+		if (key && Number.isFinite(value)) scores.set(key, value);
+	};
+	if (Array.isArray(body)) {
+		for (const row of body) {
+			const record = (row ?? {}) as Record<string, unknown>;
+			add(record.model ?? record.name, record.score ?? record.value);
+		}
+	} else if (body && typeof body === "object") {
+		for (const [name, score] of Object.entries(
+			body as Record<string, unknown>,
+		)) {
+			add(name, score);
+		}
+	}
+	return scores;
+}
+
+async function loadFile(path: string): Promise<Map<string, number>> {
+	const file = Bun.file(path);
+	if (!(await file.exists()))
+		throw new Error(`bench file not found: ${path}`);
+	return parseJsonScores(await file.text());
+}
+
+async function loadUrl(url: string): Promise<Map<string, number>> {
+	return parseJsonScores(await fetchText(url));
+}
 
 export async function resolvePrimary(opts: AbilityOptions): Promise<Resolved> {
 	const [scheme, arg] = opts.source.includes(":")
@@ -23,15 +55,12 @@ export async function resolvePrimary(opts: AbilityOptions): Promise<Resolved> {
 				data: await loadCc(),
 				label: "CommandCode Intelligence",
 			};
-		case "aa-web": {
-			const data = emptyData();
-			data.intelligence = await loadAaWebCached(Boolean(opts.refresh));
+		case "aa-web":
 			return {
 				scheme: "aa-web",
-				data,
+				data: await loadAaWeb(),
 				label: "Artificial Analysis (web, partial)",
 			};
-		}
 		case "aa": {
 			const key = opts.key ?? process.env.AA_API_KEY;
 			if (!key) {
@@ -72,15 +101,6 @@ export async function resolvePrimary(opts: AbilityOptions): Promise<Resolved> {
 	}
 }
 
-/**
- * Keyless Artificial Analysis page scrape (partial — only the models AA embeds).
- */
-export async function loadAaWeb(opts: AbilityOptions): Promise<BenchData> {
-	const data = emptyData();
-	data.intelligence = await loadAaWebCached(Boolean(opts.refresh));
-	return data;
-}
-
 /**
  * Artificial Analysis as a gap filler: the full API when a key is available,
  * otherwise the keyless page scrape (partial).
@@ -96,7 +116,7 @@ export async function loadAaFallback(
 			// fall through to the scrape
 		}
 	}
-	return { data: await loadAaWeb(opts), how: "AA web scrape" };
+	return { data: await loadAaWeb(), how: "AA web scrape" };
 }
 
 export type {

package/src/data/bench/types.ts

@@ -20,7 +20,6 @@ export interface AbilityOptions {
 	keys?: Set<string>;
 	/** Fill models the primary source misses from the other sources. */
 	fallback?: boolean;
-	refresh?: boolean;
 }
 
 export interface Resolved {

package/src/data/scrape/catalog/catalog.ts

@@ -1,3 +1,4 @@
+import { UNLIMITED } from "#~/constants/data.ts";
 import {
 	cellText,
 	headerIndex,
@@ -71,13 +72,27 @@ export function extractCatalog(
 			const rawName = nameCell(cells[0] ?? "");
 			const deal = dealIn(cells[0] ?? "");
 			if (!rawName) continue;
+			// A free model's limit cell reads "Unlimited", not a $ figure, so
+			// parseMoney returns null and the row used to be dropped entirely.
+			// Its allowance is meaningless (cost is 0), so record 0 — that keeps
+			// it out of the plan's summed credits and marks it free for --check.
+			const creditCell = cells[creditCol] ?? "";
+			const unlimited = creditHeader
+				? UNLIMITED.test(cellText(creditCell))
+				: false;
 			const allowance = creditHeader
-				? parseMoney(cells[creditCol] ?? "")
+				? (parseMoney(creditCell) ?? (unlimited ? 0 : null))
 				: (defaultAllowance ?? 0);
 			if (allowance === null) continue;
 			const key = normalizeKey(rawName);
 			if (!key) continue;
 
+			const pricing = pricingOf(cells, cols);
+			// The free cells read "Free" (already 0) but the cache-write cell is
+			// "-", which parseMoney reads as "no rate". On a free model the
+			// truthful rate is 0, not unpriced.
+			if (unlimited) pricing.cacheWrite = 0;
+
 			const score = variantScore(rawName, peak);
 			const existing = best.get(key);
 			if (existing && existing.score <= score) continue;
@@ -88,7 +103,7 @@ export function extractCatalog(
 					plan,
 					key,
 					name: displayName(rawName),
-					pricing: pricingOf(cells, cols),
+					pricing,
 					allowance,
 					...(deal ? { deal } : {}),
 				},

package/src/data/scrape/index.ts

@@ -10,6 +10,7 @@ export {
 	parseMoney,
 	parseTables,
 } from "./tables.ts";
+export { parseTabTables, type TabTable } from "./tabs.ts";
 
 export async function fetchText(url: string): Promise<string> {
 	const res = await fetch(url, {

package/src/data/scrape/tables.ts

@@ -1,4 +1,5 @@
 import { BOUNDARY } from "#~/constants/data.ts";
+import { parseTabTables } from "./tabs.ts";
 
 export type Table = string[][];
 
@@ -21,49 +22,7 @@ export function nameCell(cell: string): string {
 
 /** Parse every <table> on a page into rows of trimmed cell text. */
 export async function parseTables(html: string): Promise<Table[]> {
-	const tables: Table[] = [];
-	let table: Table | null = null;
-	let row: string[] | null = null;
-	let cell: string | null = null;
-
-	const rewriter = new HTMLRewriter()
-		.on("table", {
-			element(el) {
-				table = [];
-				el.onEndTag(() => {
-					if (table) tables.push(table);
-					table = null;
-				});
-			},
-		})
-		.on("tr", {
-			element(el) {
-				const start = table;
-				row = [];
-				el.onEndTag(() => {
-					if (row && start) start.push(row);
-					row = null;
-				});
-			},
-		})
-		.on("th, td", {
-			element(el) {
-				const current = row;
-				cell = "";
-				el.onEndTag(() => {
-					// BOUNDARY marks a text-node boundary so "$60" + "4x" stays
-					// two tokens instead of collapsing into "$604x".
-					if (current) current.push((cell ?? "").trim());
-					cell = null;
-				});
-			},
-			text(chunk) {
-				if (cell !== null) cell += `${chunk.text}${BOUNDARY}`;
-			},
-		});
-
-	await rewriter.transform(new Response(html)).text();
-	return tables;
+	return (await parseTabTables(html)).map((tab) => tab.table);
 }
 
 /**

package/src/data/scrape/tabs.ts

@@ -0,0 +1,97 @@
+import { BOUNDARY } from "#~/constants/data.ts";
+import type { Table } from "./tables.ts";
+
+/** A table plus the label of the `<tabpanel>` it sits in ("" outside tabs). */
+export interface TabTable {
+	label: string;
+	table: Table;
+}
+
+/**
+ * Parse every <table> on a page, tagging each with the label of the
+ * `role="tabpanel"` it belongs to. Starlight renders each `<TabItem label="…">`
+ * as a labelled tabpanel, so this is how two otherwise identical tables are
+ * told apart — the Go and Go Plus catalogs share headers and token rates, and
+ * differ only in the monthly-limit values.
+ *
+ * Labels come from the `[role="tab"]` control, which the document places before
+ * the panels: its end-tag fills the map, then the matching panel's table
+ * inherits its label. The tab names its panel either through `href="#id"`
+ * (Starlight's `<a role="tab">`) or `aria-controls="id"` (the v2 console page's
+ * `<button role="tab">`), so read whichever is present.
+ */
+export async function parseTabTables(html: string): Promise<TabTable[]> {
+	const labels = new Map<string, string>();
+	const tables: TabTable[] = [];
+	let panelId: string | null = null;
+	let anchorText = "";
+	let label: string | null = null;
+	let table: Table | null = null;
+	let row: string[] | null = null;
+	let cell: string | null = null;
+
+	const rewriter = new HTMLRewriter()
+		.on('[role="tab"]', {
+			element(el) {
+				const href = el.getAttribute("href");
+				panelId = href
+					? href.replace(/^#/, "")
+					: el.getAttribute("aria-controls");
+				anchorText = "";
+				el.onEndTag(() => {
+					if (panelId) labels.set(panelId, anchorText.trim());
+					panelId = null;
+				});
+			},
+			text(chunk) {
+				anchorText += chunk.text;
+			},
+		})
+		.on('div[role="tabpanel"]', {
+			element(el) {
+				label = labels.get(el.getAttribute("id") ?? "") ?? null;
+				el.onEndTag(() => {
+					label = null;
+				});
+			},
+		})
+		.on("table", {
+			element(el) {
+				table = [];
+				const start = table;
+				el.onEndTag(() => {
+					if (start)
+						tables.push({ label: label ?? "", table: start });
+					table = null;
+				});
+			},
+		})
+		.on("tr", {
+			element(el) {
+				const start = table;
+				row = [];
+				el.onEndTag(() => {
+					if (row && start) start.push(row);
+					row = null;
+				});
+			},
+		})
+		.on("th, td", {
+			element(el) {
+				const current = row;
+				cell = "";
+				el.onEndTag(() => {
+					// BOUNDARY marks a text-node boundary so "$60" + "4x" stays
+					// two tokens instead of collapsing into "$604x".
+					if (current) current.push((cell ?? "").trim());
+					cell = null;
+				});
+			},
+			text(chunk) {
+				if (cell !== null) cell += `${chunk.text}${BOUNDARY}`;
+			},
+		});
+
+	await rewriter.transform(new Response(html)).text();
+	return tables;
+}

package/src/data/sources/aa/web.ts

@@ -1,53 +1,110 @@
 import { AA_MODELS_URL } from "#~/constants/sources.ts";
+import { type BenchData, emptyData } from "#~/data/bench/types.ts";
 import { fetchText } from "#~/data/scrape/index.ts";
 import { normalizeKey } from "#~/keys.ts";
 
-/** A model label and its Artificial Analysis Intelligence Index. */
-interface Scored {
-	label: string;
-	slug?: string;
-	score: number;
-}
-
-/** Every `{label, intelligenceIndex, detailsUrl}` the models page embeds. */
-function parseEmbedded(html: string): Scored[] {
-	const re =
-		/"label":"([^"]+)","intelligenceIndex":([0-9.]+)(?:,"detailsUrl":"([^"]*)")?/g;
-	const out: Scored[] = [];
-	const seen = new Set<string>();
-	for (let match = re.exec(html); match !== null; match = re.exec(html)) {
-		const label = match[1] ?? "";
-		const score = Number(match[2]);
-		const slug = match[3]?.split("/").pop();
-		const id = `${label}|${slug ?? ""}`;
-		if (!label || !Number.isFinite(score) || seen.has(id)) continue;
-		seen.add(id);
-		out.push({ label, slug, score });
+/** The subset of an AA models-page record this parser reads. */
+interface AaModel {
+	slug?: unknown;
+	name?: unknown;
+	shortName?: unknown;
+	intelligenceIndex?: unknown;
+	timescaleData?: { medianOutputSpeed?: unknown } | null;
+}
+
+/**
+ * Decode a Next.js page's streamed RSC payload. Each chunk is a JSON string
+ * literal inside `self.__next_f.push([1,"…"])`; joining the decoded strings
+ * yields the flight text the page renders from, with plain `"initialModels":`
+ * keys instead of the `\"`-escaped form seen in the raw HTML.
+ */
+function decodeFlight(html: string): string {
+	const chunks: string[] = [];
+	const re = /self\.__next_f\.push\(\[1,("(?:[^"\\]|\\.)*")\]\)/g;
+	for (const match of html.matchAll(re)) {
+		try {
+			chunks.push(JSON.parse(match[1] ?? '""') as string);
+		} catch {
+			// A chunk we cannot read as a JSON string is skipped.
+		}
 	}
-	return out;
+	return chunks.join("");
 }
 
-function toMap(scored: Scored[]): Map<string, number> {
-	const scores = new Map<string, number>();
-	for (const { label, slug, score } of scored) {
-		// slug is the more precise key; label is the fallback.
-		if (slug) scores.set(normalizeKey(slug), score);
-		const labelKey = normalizeKey(label);
-		if (labelKey && !scores.has(labelKey)) scores.set(labelKey, score);
+/** The JSON array value of `"key"` in `text`, bracket-matched string-aware. */
+function readArray(text: string, key: string): unknown[] | null {
+	const at = text.indexOf(`"${key}":`);
+	if (at < 0) return null;
+	const open = text.indexOf("[", at);
+	if (open < 0) return null;
+	let depth = 0;
+	let inString = false;
+	for (let i = open; i < text.length; i++) {
+		const char = text[i];
+		if (inString) {
+			if (char === "\\") i++;
+			else if (char === '"') inString = false;
+			continue;
+		}
+		if (char === '"') inString = true;
+		else if (char === "[") depth++;
+		else if (char === "]") {
+			depth--;
+			if (depth === 0) {
+				try {
+					return JSON.parse(text.slice(open, i + 1)) as unknown[];
+				} catch {
+					return null;
+				}
+			}
+		}
 	}
-	return scores;
+	return null;
+}
+
+/** A finite, positive number; `null` for anything else (incl. 0 = unmeasured). */
+function positive(value: unknown): number | null {
+	return typeof value === "number" && Number.isFinite(value) && value > 0
+		? value
+		: null;
 }
 
-/** Keyless scrape of the Artificial Analysis models page. Only the models that
- * page embeds (its chart top-N) are covered, so this is a fallback, not a full
- * catalog.
+function labelOf(model: AaModel): string {
+	if (typeof model.name === "string") return model.name;
+	return typeof model.shortName === "string" ? model.shortName : "";
+}
+
+function keyOf(value: unknown): string {
+	return typeof value === "string" ? normalizeKey(value) : "";
+}
+
+/**
+ * Pure parser over the AA models page. Keyless and live: the page embeds its
+ * `initialModels` array in the RSC flight payload, each record carrying the
+ * Intelligence Index and (mostly) a median output speed. Only that embedded
+ * top-N is covered, so this is a partial source.
  */
-export async function loadAaWeb(): Promise<Map<string, number>> {
-	const html = await fetchText(AA_MODELS_URL);
-	return parseAaWeb(html);
+export function parseAaWeb(html: string): BenchData {
+	const data = emptyData();
+	const models = readArray(decodeFlight(html) || html, "initialModels");
+	if (!models) return data;
+	for (const raw of models) {
+		const model = (raw ?? {}) as AaModel;
+		// slug is the precise key; the display name is the fallback.
+		const keys = [keyOf(model.slug), keyOf(labelOf(model))].filter(Boolean);
+		const score = positive(model.intelligenceIndex);
+		const speed = positive(model.timescaleData?.medianOutputSpeed);
+		for (const key of keys) {
+			if (score !== null && !data.intelligence.has(key)) {
+				data.intelligence.set(key, score);
+			}
+			if (speed !== null && !data.tps.has(key)) data.tps.set(key, speed);
+		}
+	}
+	return data;
 }
 
-/** Pure parser over the AA models page HTML, for tests and the scraper. */
-export function parseAaWeb(html: string): Map<string, number> {
-	return toMap(parseEmbedded(html));
+/** Fetch and parse the AA models page. Live, per run — nothing cached. */
+export async function loadAaWeb(): Promise<BenchData> {
+	return parseAaWeb(await fetchText(AA_MODELS_URL));
 }

package/src/data/sources/opencode.ts

@@ -1,40 +1,58 @@
-import {
-	DOC_URL,
-	OC_MODELS_URL,
-	PRICE_PER_MONTH,
-} from "#~/constants/sources.ts";
+import { DOC_URL, OC_MODELS_URL, OC_PLANS } from "#~/constants/sources.ts";
 import {
 	extractCatalog,
 	fetchText,
-	parseTables,
+	parseTabTables,
 } from "#~/data/scrape/index.ts";
 import type { CatalogEntry, PlanInfo } from "#~/types.ts";
 
-/** Per-model token rates + monthly usage limit for OpenCode Go. */
-export async function loadOcGoCatalog(peak = false): Promise<CatalogEntry[]> {
+function planDef(planId: string) {
+	const def = OC_PLANS[planId];
+	if (!def) {
+		throw new Error(
+			`unknown OpenCode plan "${planId}" (have: ${Object.keys(OC_PLANS).join(", ")})`,
+		);
+	}
+	return def;
+}
+
+/**
+ * Per-model token rates + monthly usage limit for an OpenCode Go plan. Both
+ * plans share one price list, so the tab label is what selects the right
+ * allowance table: identical headers and rates, different monthly limits.
+ */
+export async function loadOcGoCatalog(
+	planId: string,
+	peak = false,
+): Promise<CatalogEntry[]> {
+	const def = planDef(planId);
 	const html = await fetchText(DOC_URL);
-	const tables = await parseTables(html);
-	const entries = extractCatalog(tables, {
-		provider: "oc-go",
-		plan: "Go",
-		creditHeader: /monthly limit/i,
-		peak,
-	});
+	const tabs = await parseTabTables(html);
+	const entries = extractCatalog(
+		tabs.filter((tab) => tab.label === def.label).map((tab) => tab.table),
+		{
+			provider: "oc-go",
+			plan: def.label,
+			creditHeader: /monthly limit/i,
+			peak,
+		},
+	);
 	if (entries.length === 0) {
 		throw new Error(
-			`no model table parsed from ${DOC_URL} — docs layout may have changed`,
+			`no model table parsed for the "${def.label}" plan from ${DOC_URL} — docs layout may have changed`,
 		);
 	}
 	return entries;
 }
 
-/** OpenCode Go is a flat $10/mo; limits are per-model, so there is no shared pool. */
-export function ocGoPlan(entries: CatalogEntry[]): PlanInfo {
+/** A Go plan is flat-priced; limits are per-model, so there is no shared pool. */
+export function ocGoPlan(entries: CatalogEntry[], planId: string): PlanInfo {
+	const def = planDef(planId);
 	return {
 		provider: "oc-go",
-		id: "go",
-		label: "Go",
-		price: PRICE_PER_MONTH,
+		id: planId,
+		label: def.label,
+		price: def.price,
 		credits: entries.reduce((sum, e) => sum + e.allowance, 0),
 		fiveHour: null,
 		weekly: null,

package/src/keys.ts

@@ -14,6 +14,12 @@ export function normalizeKey(name: string): string {
 	// Drop a vendor prefix like "deepseek/", "z-ai/", "opencode-go/".
 	const parts = s.split("/");
 	s = parts[parts.length - 1] ?? s;
+	// OpenCode's docs append a "Free" marker to every free model ("Step 5
+	// Preview Free"); the other catalog omits it. That marker is systematic, not
+	// per-model branding, so strip one trailing occurrence here — never add
+	// per-model ALIASES entries for it. Trailing only: "Freestyle" or "Free Tier
+	// X" keeps its token.
+	s = s.replace(/[\s_-]+free\s*$/i, " ");
 	s = s.replace(/[^a-z0-9]+/g, "");
 	return ALIASES[s] ?? s;
 }

package/src/data/bench/store.ts

@@ -1,169 +0,0 @@
-import { CACHE_TTL_MS } from "#~/constants/sources.ts";
-import { fetchText } from "#~/data/scrape/index.ts";
-import { normalizeKey } from "#~/keys.ts";
-
-function parseJsonScores(text: string): Map<string, number> {
-	const body = JSON.parse(text) as unknown;
-	const scores = new Map<string, number>();
-	const add = (name: unknown, score: unknown): void => {
-		const key = typeof name === "string" ? normalizeKey(name) : "";
-		const value = Number(score);
-		if (key && Number.isFinite(value)) scores.set(key, value);
-	};
-	if (Array.isArray(body)) {
-		for (const row of body) {
-			const record = (row ?? {}) as Record<string, unknown>;
-			add(record.model ?? record.name, record.score ?? record.value);
-		}
-	} else if (body && typeof body === "object") {
-		for (const [name, score] of Object.entries(
-			body as Record<string, unknown>,
-		)) {
-			add(name, score);
-		}
-	}
-	return scores;
-}
-
-export async function loadFile(path: string): Promise<Map<string, number>> {
-	const file = Bun.file(path);
-	if (!(await file.exists()))
-		throw new Error(`bench file not found: ${path}`);
-	return parseJsonScores(await file.text());
-}
-
-export async function loadUrl(url: string): Promise<Map<string, number>> {
-	return parseJsonScores(await fetchText(url));
-}
-
-import { mkdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { loadAaWeb } from "#~/data/sources/aa/web.ts";
-
-function cachePath(): string {
-	const base = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
-	return join(base, "mpc", "ability-aa-web.json");
-}
-
-async function readCache(
-	refresh: boolean,
-): Promise<Map<string, number> | null> {
-	if (refresh) return null;
-	try {
-		const file = Bun.file(cachePath());
-		if (!(await file.exists())) return null;
-		const raw = (await file.json()) as {
-			fetchedAt?: number;
-			scores?: Record<string, number>;
-		};
-		if (!raw.fetchedAt || Date.now() - raw.fetchedAt > CACHE_TTL_MS)
-			return null;
-		return new Map(Object.entries(raw.scores ?? {}));
-	} catch {
-		return null;
-	}
-}
-
-async function writeCache(scores: Map<string, number>): Promise<void> {
-	try {
-		const path = cachePath();
-		await mkdir(join(path, ".."), { recursive: true });
-		await Bun.write(
-			path,
-			JSON.stringify({
-				fetchedAt: Date.now(),
-				scores: Object.fromEntries(scores),
-			}),
-		);
-	} catch {
-		// Cache is best-effort.
-	}
-}
-
-/** Keyless AA page scrape, cached on disk. */
-export async function loadAaWebCached(
-	refresh: boolean,
-): Promise<Map<string, number>> {
-	const cached = await readCache(refresh);
-	if (cached) return cached;
-	const scores = await loadAaWeb();
-	await writeCache(scores);
-	return scores;
-}
-
-/**
- * The last good benchmark result, whole. The per-source caches above only cover
- * the AA page scrape; this one covers the result mpc actually returned, so a
- * source that is down (or a page that silently dropped a column, as the
- * CommandCode plan pages did with Tok/s) falls back to the scores we already
- * have instead of blanking the ability/tps columns.
- */
-export interface CachedAbility {
-	intelligence: Map<string, number>;
-	tps: Map<string, number>;
-}
-
-function abilityCachePath(): string {
-	const base = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
-	return join(base, "mpc", "ability.json");
-}
-
-export async function readAbilityCache(
-	refresh = false,
-): Promise<CachedAbility | null> {
-	if (refresh) return null;
-	try {
-		const file = Bun.file(abilityCachePath());
-		if (!(await file.exists())) return null;
-		const raw = (await file.json()) as {
-			fetchedAt?: number;
-			intelligence?: Record<string, number>;
-			tps?: Record<string, number>;
-		};
-		if (!raw.fetchedAt || Date.now() - raw.fetchedAt > CACHE_TTL_MS)
-			return null;
-		return {
-			intelligence: new Map(Object.entries(raw.intelligence ?? {})),
-			tps: new Map(Object.entries(raw.tps ?? {})),
-		};
-	} catch {
-		return null;
-	}
-}
-
-export async function writeAbilityCache(data: CachedAbility): Promise<void> {
-	try {
-		const path = abilityCachePath();
-		await mkdir(join(path, ".."), { recursive: true });
-		await Bun.write(
-			path,
-			JSON.stringify({
-				fetchedAt: Date.now(),
-				intelligence: Object.fromEntries(data.intelligence),
-				tps: Object.fromEntries(data.tps),
-			}),
-		);
-	} catch {
-		// Cache is best-effort.
-	}
-}
-
-/** Fill keys the live run is missing from `cached`. Returns how many were added. */
-export function fillFromCache(
-	data: CachedAbility,
-	cached: CachedAbility,
-): number {
-	let added = 0;
-	for (const [into, from] of [
-		[data.intelligence, cached.intelligence],
-		[data.tps, cached.tps],
-	] as const) {
-		for (const [key, value] of from) {
-			if (into.has(key)) continue;
-			into.set(key, value);
-			added++;
-		}
-	}
-	return added;
-}