@furifont/core 0.3.0 → 0.4.1

package/dist/index.mjs

@@ -10,20 +10,8 @@ const DEFAULTS = {
 	plan: {
 		family: "Furifont Sans",
 		rubyScript: "hiragana",
-		/** Newspaper frequency buckets, nf01 to nf48: the window of words that get ruby. All of them: it adds about 400 glyphs. */
-		nfMin: 1,
-		nfMax: 48,
-		/** JMdict priority tags that select a word whatever its bucket: the first tier of each list, which JMdict marks as common. */
-		selectTags: [
-			"ichi1",
-			"news1",
-			"spec1",
-			"gai1"
-		],
-		/** Uses in Tatoeba's example sentences that select a word whatever its bucket: about 1,000 more words, and 50 glyphs. */
-		minTatoeba: 3,
-		places: true,
-		untagged: true,
+		/** No word is left bare for being common; every word of every source gets ruby. */
+		skip: 0,
 		isolated: true,
 		isolatedMinShare: .8,
 		/** Sizes in em, relative to the base font. */
@@ -82,8 +70,8 @@ const PREBUILT = {
 		style: "VF",
 		weights: [250, 900]
 	},
-	/** Options set on every prebuilt font over the defaults above, such as `{ nfMax: 24 }`. */
-	options: {}
+	/** Options set on every prebuilt font over the defaults above, such as `{ take: 20000 }`. */
+	options: { take: 4e4 }
 };
 /**
 * The sequence, 。 and VS1, a page measures to tell which version of Furifont
@@ -101,16 +89,22 @@ const HAN = /\p{Script=Han}/u;
 function isHan(char) {
 	return HAN.test(char);
 }
+/** Spans of a JmdictFurigana alignment; a loop, not splits, as the planner parses the 400,000 readings of the dictionary as it starts. */
 function parseFurigana(furigana) {
-	return furigana.split(";").filter(Boolean).map((part) => {
-		const [range, ruby = ""] = part.split(":");
-		const [start, end = start] = range.split("-").map(Number);
-		return {
+	const spans = [];
+	for (const part of furigana.split(";")) {
+		if (!part) continue;
+		const colon = part.indexOf(":");
+		const range = colon < 0 ? part : part.slice(0, colon);
+		const dash = range.indexOf("-");
+		const start = Number(dash < 0 ? range : range.slice(0, dash));
+		spans.push({
 			start,
-			end: end + 1,
-			ruby
-		};
-	});
+			end: (dash < 0 ? start : Number(range.slice(dash + 1))) + 1,
+			ruby: colon < 0 ? "" : part.slice(colon + 1)
+		});
+	}
+	return spans;
 }
 /**
 * Splits a form into its Han runs. Browsers itemize text by script before
@@ -179,6 +173,413 @@ function formatNotation(text, spans) {
 	}
 	return out + chars.slice(at).join("");
 }
+function getOrCreate(map, key, create) {
+	let value = map.get(key);
+	if (value === void 0) map.set(key, value = create());
+	return value;
+}
+//#endregion
+//#region src/schema.ts
+const RUBY_SCRIPTS = [
+	"hiragana",
+	"katakanaOn",
+	"hepburn"
+];
+/** The dictionary's manually maintained sources. */
+const MANUAL_SOURCES = [
+	"mahjong-yaku",
+	"jr-stations",
+	"yojijukugo",
+	"japan-post"
+];
+/**
+* The sources a plan takes words from: any JMdict word; JMdict's priority
+* lists (both tiers of each) and its newspaper ranking; words Tatoeba's
+* sentences use at least three times; JMnedict's place names; the manual lists.
+*/
+const WORD_SOURCES = [
+	"jmdict",
+	"ichi",
+	"news",
+	"spec",
+	"gai",
+	"nf",
+	"tatoeba",
+	"place",
+	...MANUAL_SOURCES
+];
+/** Easiest first. */
+const JLPT_LEVELS = [
+	"N5",
+	"N4",
+	"N3",
+	"N2",
+	"N1"
+];
+/**
+* Every source a reading may have, a bit each in this order: the word
+* sources, then the easiest JLPT level listing it, `inflecting` (a kanji read
+* before okurigana in a JMdict word no list tags, such as 奉る) and `default`,
+* the dictionary's curated default.
+*/
+const SOURCES = [
+	...WORD_SOURCES,
+	...JLPT_LEVELS,
+	"inflecting",
+	"default"
+];
+const sourceBit = (source) => 1 << SOURCES.indexOf(source);
+/** The sources a mask of `SOURCES` bits names. */
+const sourcesIn = (mask) => SOURCES.filter((source) => mask & sourceBit(source));
+/** Sizes in em, relative to the base font. */
+const RubyMetricsSchema = v.object({
+	/** Ruby size relative to the base characters. */
+	rubyScale: v.optional(v.pipe(v.number(), v.minValue(.2), v.maxValue(.8)), DEFAULTS.plan.metrics.rubyScale),
+	/** Space between the top of the em box and the bottom of the ruby. */
+	rubyGap: v.optional(v.pipe(v.number(), v.minValue(0), v.maxValue(.5)), DEFAULTS.plan.metrics.rubyGap),
+	/** Ruby is squeezed horizontally down to this scale before it may overhang. */
+	compressionFloor: v.optional(v.pipe(v.number(), v.minValue(.3), v.maxValue(1)), DEFAULTS.plan.metrics.compressionFloor),
+	/** Widest a ruby may get, overhanging its base symmetrically. */
+	maxRubyWidth: v.optional(v.pipe(v.number(), v.minValue(1), v.maxValue(3)), DEFAULTS.plan.metrics.maxRubyWidth)
+});
+const Count = v.pipe(v.number(), v.integer(), v.minValue(0));
+const PlanOptionsSchema = v.object({
+	family: v.optional(v.pipe(v.string(), v.trim(), v.nonEmpty(), v.check((name) => !/source/i.test(name), "Source is a reserved font name of the base font")), DEFAULTS.plan.family),
+	rubyScript: v.optional(v.picklist(RUBY_SCRIPTS), DEFAULTS.plan.rubyScript),
+	/** The sources whose words get ruby. */
+	sources: v.optional(v.array(v.picklist(WORD_SOURCES)), () => [...WORD_SOURCES]),
+	/** The most common words left bare, by score: a reader knows them. Lone kanji count too. */
+	skip: v.optional(Count, DEFAULTS.plan.skip),
+	/** How many words get ruby after those skipped, by score; all of them when left out. */
+	take: v.optional(v.pipe(Count, v.minValue(1))),
+	/** Words on the JLPT lists of this level and every easier one stay bare. */
+	skipJlpt: v.optional(v.picklist(JLPT_LEVELS)),
+	/** Annotate a kanji alone in its run, or one no word claims after another kanji (a suffix); when off, only selectors give them ruby. */
+	isolated: v.optional(v.boolean(), DEFAULTS.plan.isolated),
+	/** A kanji alone in its run is annotated only when one reading has this share of the evidence. */
+	isolatedMinShare: v.optional(v.pipe(v.number(), v.minValue(.5), v.maxValue(1)), DEFAULTS.plan.isolatedMinShare),
+	words: v.optional(v.object({
+		/** Extra words in inline notation, `日[に]本[ほん]`. */
+		add: v.optional(v.array(v.string()), []),
+		/** Written forms never to annotate. */
+		remove: v.optional(v.array(v.string()), []),
+		/** Readings to make the default, in inline notation. */
+		pin: v.optional(v.array(v.string()), [])
+	}), {}),
+	metrics: v.optional(RubyMetricsSchema, {})
+});
+function resolveOptions(input = {}) {
+	return v.parse(PlanOptionsSchema, input);
+}
+const Codepoint = v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(1114111));
+/**
+* The contract between the planner and the compiler. The compiler makes no
+* decision about readings: it draws what `glyphs` describes and compiles `fea`.
+* In `fea`, base characters are named `uniXXXX` / `uXXXXX` after their codepoint.
+*/
+const PlanSchema = v.object({
+	version: v.literal(1),
+	names: v.object({
+		family: v.string(),
+		description: v.string()
+	}),
+	metrics: v.object({
+		rubyScale: v.number(),
+		rubyGap: v.number(),
+		compressionFloor: v.number(),
+		maxRubyWidth: v.number()
+	}),
+	/** Base characters the rules name; each must be in the base font's cmap. */
+	codepoints: v.array(Codepoint),
+	/**
+	* Base + variation selector sequences to map in `cmap` format 14, each to an
+	* empty glyph named `name`, with the base's advance: the rules replace it.
+	*/
+	variants: v.array(v.object({
+		name: v.pipe(v.string(), v.regex(/^[A-Z_][\w.]{0,62}$/i)),
+		base: Codepoint,
+		selector: Codepoint
+	})),
+	glyphs: v.array(v.object({
+		name: v.pipe(v.string(), v.regex(/^[A-Z_][\w.]{0,62}$/i)),
+		/** The base characters drawn side by side; more than one makes a ligature. */
+		bases: v.pipe(v.array(Codepoint), v.minLength(1)),
+		/** Ruby text drawn above characters `[start, end)` of `bases`. */
+		ruby: v.array(v.object({
+			start: v.number(),
+			end: v.number(),
+			text: v.pipe(v.string(), v.nonEmpty())
+		}))
+	})),
+	fea: v.string(),
+	/** Subset the base font to these codepoints before building (live previews). */
+	subset: v.optional(v.array(Codepoint)),
+	/** Shaping checks the compiler runs on its output: `text` must shape to `glyphs`. */
+	smoke: v.array(v.object({
+		text: v.string(),
+		glyphs: v.array(v.string())
+	}))
+});
+/**
+* The bounds of a reading's score, 0 to 100: above `tagged`, a word JMdict's
+* lists tag, by its weight; above `used`, one Tatoeba's sentences use (20 and
+* its uses, up to 50); above `listed`, one a manual list (15) or JMnedict (10)
+* names; any other JMdict word scores `listed`.
+*/
+const SCORE = {
+	tagged: 50,
+	used: 20,
+	listed: 5
+};
+/** Score points per factor e of weight: a point is a twelfth, about 9%, of it. */
+const POINTS = 12;
+/**
+* The score of a tagged reading of corpus weight `weight`, at most 1: 1 / its
+* newspaper bucket, or a lone kanji's share of its uses. It is 100 for 1, 92
+* for 1/2, 54 for 1/48; a weight too small to score above `tagged` scores 0.
+*/
+function scoreOf(weight) {
+	const score = Math.round(100 + POINTS * Math.log(weight));
+	return score > SCORE.tagged ? score : 0;
+}
+/** The corpus weight of a reading's score, which `scoreOf` gives; 0 for one no list tags. */
+const weightOf = (score) => score > SCORE.tagged ? Math.exp((score - 100) / POINTS) : 0;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isReading = (value) => Array.isArray(value) && value.length === 2 && value.every(Number.isInteger) && value[0] >= 0 && value[0] <= 100 && value[1] > 0 && value[1] < 1 << SOURCES.length;
+/** Readings by run or kanji, then by alignment or reading. Checked by hand: valibot takes seconds over the 400,000 readings of the dictionary. */
+const ReadingsSchema = v.custom((input) => isRecord(input) && Object.values(input).every((readings) => isRecord(readings) && Object.values(readings).every(isReading)), "Expected readings by run, each [score, sources]");
+/** The bit of each source, which the file writes for its readers. */
+const SOURCE_BITS = Object.fromEntries(SOURCES.map((source) => [source, sourceBit(source)]));
+/**
+* The compiled dictionary, the contract between `@furifont/dictionary` and
+* the planner: readings by the Han run a font sees, each with its score and
+* sources. A run's readings come ranked, the default first. Run readings are
+* JmdictFurigana alignments within the run.
+*/
+const DictionarySchema = v.object({
+	/** Source datasets and the version each was compiled from. */
+	versions: v.record(v.string(), v.string()),
+	/** The bit of each source in the readings' masks. */
+	sources: v.custom((input) => isRecord(input) && JSON.stringify(input) === JSON.stringify(SOURCE_BITS), "Expected the sources of this version of @furifont/core"),
+	/** Kanji to its on'yomi, in hiragana. */
+	onyomi: v.record(v.string(), v.array(v.string())),
+	/** Runs of two or more kanji, then their alignments: `{ 日本: { '0-1:にほん': [75, 61] } }`. */
+	runs: ReadingsSchema,
+	/** Kanji alone in a run, then their readings: `{ 来: { く: [98, 2101] } }`. */
+	kanji: ReadingsSchema,
+	/** Written forms never to annotate, such as 月, whose reading alone is a guess; users' removals add to them. */
+	bare: v.array(v.string())
+});
+/** The file `DictionarySchema` reads: an entry a line. */
+function formatDictionary(dictionary) {
+	const lines = (table) => Object.entries(table).map(([key, value]) => `${JSON.stringify(key)}:${JSON.stringify(value)}`).join(",\n");
+	return `{
+"versions":${JSON.stringify(dictionary.versions)},
+"sources":${JSON.stringify(dictionary.sources)},
+"bare":${JSON.stringify(dictionary.bare)},
+"onyomi":{
+${lines(dictionary.onyomi)}
+},
+"kanji":{
+${lines(dictionary.kanji)}
+},
+"runs":{
+${lines(dictionary.runs)}
+}
+}
+`;
+}
+//#endregion
+//#region src/fuse.ts
+/** JMdict orders readings within a form; a run read inside a longer form ranks after the form's own readings. */
+const OTHER_FORM_ORDER = 1e3;
+const OKURIGANA = /[\u3041-\u3096]/;
+/** Uses in Tatoeba's sentences that make a word one of the sentences'. */
+const MIN_USES = 3;
+/** With this many uses alone in the sentences, they decide how a lone kanji reads rather than the word lists. */
+const LONE_MIN_USES = 20;
+/** A tagged reading of a kanji that the sentences decide keeps this score at most, so it stays among the kanji's readings. */
+const LONE_TAGGED_FLOOR = 60;
+const PRIORITY_LISTS = [
+	"ichi",
+	"news",
+	"spec",
+	"gai"
+];
+const MANUAL_BITS = MANUAL_SOURCES.reduce((mask, name) => mask | sourceBit(name), 0);
+/** The evidence of `text` read as `key`, met for the first time or not. */
+function evidenceOf(table, text, key) {
+	return getOrCreate(getOrCreate(table, text, () => /* @__PURE__ */ new Map()), key, () => ({ sources: 0 }));
+}
+/** Spans as a JmdictFurigana alignment: `0:に;1:ほん`, `0-1:きょう`. */
+function formatFurigana(spans) {
+	return spans.map((s) => `${s.end - s.start > 1 ? `${s.start}-${s.end - 1}` : s.start}:${s.ruby}`).join(";");
+}
+/** Rough corpus frequency of a tagged entry, in newspaper buckets of ~500 words each. */
+function rankOf(entry) {
+	if (entry.priority) return entry.nf || Number(/nf(\d+)/.exec(entry.priority)?.[1] ?? 0) || (/[a-z]1\b/.test(entry.priority) ? 24 : 48);
+}
+/** Adds what a JMdict entry says of a reading: its lists, its rank and its JLPT level. */
+function addEntry(into, entry) {
+	into.sources |= sourceBit("jmdict");
+	if (entry.jlpt) into.jlpt = Math.max(into.jlpt ?? 0, entry.jlpt);
+	const rank = rankOf(entry);
+	if (!rank) return;
+	into.rank = Math.min(into.rank ?? rank, rank);
+	if (entry.nf) into.sources |= sourceBit("nf");
+	for (const list of PRIORITY_LISTS.filter((list) => new RegExp(`\\b${list}[12]\\b`).test(entry.priority))) into.sources |= sourceBit(list);
+}
+function addRun(runs, run, entry) {
+	const evidence = evidenceOf(runs, run.text, formatFurigana(run.spans));
+	const order = run.text === entry.form ? entry.order : OTHER_FORM_ORDER + entry.order;
+	evidence.order = Math.min(evidence.order ?? order, order);
+	if (entry.tatoeba) evidence.uses = Math.max(evidence.uses ?? 0, entry.tatoeba);
+	addEntry(evidence, entry);
+}
+function addKanji(kanji, run, entry) {
+	const ruby = run.spans[0].ruby;
+	if (entry.tatoeba && !entry.conjugatesReading) {
+		const uses = getOrCreate(kanji.uses, run.text, () => /* @__PURE__ */ new Map());
+		uses.set(ruby, (uses.get(ruby) ?? 0) + entry.tatoeba);
+	}
+	if (rankOf(entry)) for (const r of entry.conjugatesReading && ruby === "く" ? [
+		"く",
+		"き",
+		"こ"
+	] : [ruby]) addEntry(evidenceOf(kanji.tagged, run.text, r), entry);
+	else if (OKURIGANA.test(entry.form[entry.form.indexOf(run.text) + run.text.length] ?? "")) getOrCreate(kanji.inflecting, run.text, () => /* @__PURE__ */ new Set()).add(ruby);
+}
+/** Its sources with the JLPT level and Tatoeba's sentences as bits. */
+function sourcesOf(evidence) {
+	const level = evidence.jlpt && JLPT_LEVELS[5 - evidence.jlpt];
+	return evidence.sources | (level ? sourceBit(level) : 0) | ((evidence.uses ?? 0) >= MIN_USES ? sourceBit("tatoeba") : 0);
+}
+/** How common a run's reading is, by the most telling of its sources. */
+function runScore(evidence) {
+	const uses = evidence.uses ?? 0;
+	return Math.max(evidence.rank ? scoreOf(1 / evidence.rank) : 0, uses >= MIN_USES ? SCORE.used + Math.min(uses, SCORE.tagged - SCORE.used) : 0, evidence.sources & MANUAL_BITS ? 15 : 0, evidence.sources & sourceBit("place") ? 10 : 0, evidence.order === void 0 ? 0 : SCORE.listed);
+}
+const tier = (score) => [
+	SCORE.tagged,
+	SCORE.used,
+	SCORE.listed
+].filter((bound) => score > bound).length;
+/**
+* A run's readings ranked, the default first: tagged ones, then those the
+* sentences use, each by JMdict's order; then the lists' and the place
+* names', then the other JMdict words', each by score. Readings of the same
+* kana are one, under the alignment that splits them most: 倉本 くら・もと
+* rather than くらもと.
+*/
+function rankReadings(readings) {
+	const byKana = /* @__PURE__ */ new Map();
+	for (const [key, evidence] of readings) {
+		const spans = parseFurigana(key);
+		const reading = {
+			key,
+			spans,
+			score: runScore(evidence),
+			sources: sourcesOf(evidence),
+			order: evidence.order ?? Infinity
+		};
+		const kana = spans.map((s) => s.ruby).join("");
+		const same = byKana.get(kana);
+		if (!same) {
+			byKana.set(kana, reading);
+			continue;
+		}
+		const finer = reading.spans.length > same.spans.length ? reading : same;
+		byKana.set(kana, {
+			...finer,
+			score: Math.max(same.score, reading.score),
+			sources: same.sources | reading.sources,
+			order: Math.min(same.order, reading.order)
+		});
+	}
+	return [...byKana.values()].sort((a, b) => tier(b.score) - tier(a.score) || (tier(a.score) > 1 ? a.order - b.order || b.score - a.score : b.score - a.score || a.order - b.order)).map((r) => [r.key, [r.score, r.sources]]);
+}
+/**
+* When the sentences use a kanji alone often enough to tell, each reading
+* scores by its share of those uses, so that its weight in the planner is
+* about that share; a tagged one keeps a little, to stay among its readings.
+*/
+function scoreUses(readings, uses) {
+	const total = [...uses.values()].reduce((a, b) => a + b, 0);
+	if (total < LONE_MIN_USES) return;
+	for (const reading of readings.values()) reading[0] = Math.min(reading[0], LONE_TAGGED_FLOOR);
+	for (const [ruby, n] of uses) {
+		const reading = getOrCreate(readings, ruby, () => [0, sourceBit("jmdict")]);
+		reading[0] = Math.max(reading[0], scoreOf(n / total));
+		if (n >= MIN_USES) reading[1] |= sourceBit("tatoeba");
+	}
+}
+/** A lone kanji's readings, the most common first: tagged words and the sentences score them; rare verbs add readings that score nothing. */
+function kanjiReadings(kanji) {
+	const out = /* @__PURE__ */ new Map();
+	for (const [text, tagged] of kanji.tagged) {
+		const readings = new Map([...tagged].map(([ruby, evidence]) => [ruby, [scoreOf(1 / evidence.rank), sourcesOf(evidence)]]));
+		scoreUses(readings, kanji.uses.get(text) ?? /* @__PURE__ */ new Map());
+		out.set(text, new Map([...readings].filter(([, [score]]) => score).sort((a, b) => b[1][0] - a[1][0])));
+	}
+	for (const [text, rubies] of kanji.inflecting) {
+		const readings = getOrCreate(out, text, () => /* @__PURE__ */ new Map());
+		for (const ruby of rubies) {
+			const [score, sources] = readings.get(ruby) ?? [0, sourceBit("jmdict")];
+			readings.set(ruby, [score, sources | sourceBit("inflecting")]);
+		}
+	}
+	return out;
+}
+function notationRuns$1(notation) {
+	const { form, spans } = parseNotation(notation);
+	return hanRuns(form, spans);
+}
+/** The runs each list names, as the planner reads them: no lone kanji, which would be no evidence for the kanji's reading. */
+function listedRuns(sources) {
+	const manual = MANUAL_SOURCES.flatMap((name) => (sources.manual[name] ?? []).flatMap(notationRuns$1).map((run) => [run, name]));
+	const places = sources.places.flatMap((place) => {
+		const runs = hanRuns(place.form, parseFurigana(place.furigana));
+		return runs.length === 1 && runs[0].text === place.form ? [[runs[0], "place"]] : [];
+	});
+	return [...manual, ...places].filter(([run]) => [...run.text].length > 1);
+}
+function addSource(readings, key, source) {
+	const [score, sources] = readings.get(key) ?? [0, 0];
+	readings.set(key, [score, sources | sourceBit(source)]);
+}
+/**
+* Merges every source into the readings of the Han runs a font sees, each
+* reading with its score and sources. What no plan can use is left out: a
+* word's runs with an unannotated kanji, lone kanji of the lists or of words
+* no list tags but before okurigana, and the on'yomi of kanji no reading uses.
+*/
+function fuseDictionary(sources) {
+	const runs = /* @__PURE__ */ new Map();
+	const kanji = {
+		tagged: /* @__PURE__ */ new Map(),
+		uses: /* @__PURE__ */ new Map(),
+		inflecting: /* @__PURE__ */ new Map()
+	};
+	for (const entry of sources.entries) for (const run of hanRuns(entry.form, parseFurigana(entry.furigana))) if ([...run.text].length > 1) addRun(runs, run, entry);
+	else addKanji(kanji, run, entry);
+	for (const [run, name] of listedRuns(sources)) evidenceOf(runs, run.text, formatFurigana(run.spans)).sources |= sourceBit(name);
+	const ranked = new Map([...runs].map(([text, readings]) => [text, new Map(rankReadings(readings))]));
+	const lone = kanjiReadings(kanji);
+	for (const run of sources.defaults.flatMap(notationRuns$1)) {
+		const [table, key] = [...run.text].length > 1 ? [ranked, formatFurigana(run.spans)] : [lone, run.spans[0].ruby];
+		addSource(getOrCreate(table, run.text, () => /* @__PURE__ */ new Map()), key, "default");
+	}
+	const used = new Set([...ranked.keys(), ...lone.keys()].flatMap((text) => [...text]));
+	const toRecord = (table) => Object.fromEntries([...table].map(([text, readings]) => [text, Object.fromEntries(readings)]));
+	return {
+		versions: sources.versions,
+		sources: SOURCE_BITS,
+		onyomi: Object.fromEntries(Object.entries(sources.onyomi).filter(([k]) => used.has(k))),
+		runs: toRecord(ranked),
+		kanji: toRecord(lone),
+		bare: sources.bare
+	};
+}
 //#endregion
 //#region src/glyphs.ts
 function glyphName(codepoint) {
@@ -529,94 +930,67 @@ const MIN_ALTERNATE_SHARE = .02;
 /** A suffix reading is the one a kanji takes in this share of the runs it ends, out of at least `SUFFIX_MIN_RUNS`. */
 const SUFFIX_MIN_SHARE = .9;
 const SUFFIX_MIN_RUNS = 10;
-/** With this many uses alone in the example sentences, they decide a lone kanji rather than the word lists. */
-const LONE_MIN_USES = 20;
-/** JMdict orders readings within a form; a run read inside a longer form ranks after the form's own readings. */
-const OTHER_FORM_ORDER = 1e3;
 const length = (text) => [...text].length;
 function spanKey(spans) {
 	return spans.map((s) => `${s.start}-${s.end}:${s.ruby}`).join(";");
 }
+/** Pinned first; then readings that are evidence, before a place name's or a rare word's; then as the dictionary ranks them. */
 function rank(a, b) {
-	return (b.pinned ?? 0) - (a.pinned ?? 0) || Number(b.tagged) - Number(a.tagged) || a.order - b.order || b.weight - a.weight;
+	return (b.pinned ?? 0) - (a.pinned ?? 0) || Number(a.place ?? false) - Number(b.place ?? false) || a.order - b.order;
 }
-/** Rough corpus frequency of an entry: nf buckets hold ~500 words each, ranked by frequency. */
-function entryWeight(entry) {
-	if (!entry.priority) return 0;
-	const nf = entry.nf || Number(/nf(\d+)/.exec(entry.priority)?.[1] ?? 0);
-	if (nf) return 1 / nf;
-	return /[a-z]1\b/.test(entry.priority) ? 1 / 24 : 1 / 48;
-}
-function keepBest(current, value) {
-	current.weight = Math.max(current.weight, value.weight);
-	if (value.nf && (!current.nf || value.nf < current.nf)) current.nf = value.nf;
-	current.jlpt = Math.max(current.jlpt, value.jlpt);
-	for (const tag of value.tags) current.tags.add(tag);
-}
-function priorityTags(entry) {
-	return new Set(entry.priority.split(" ").filter(Boolean));
-}
-function getOrCreate(map, key, create) {
-	let value = map.get(key);
-	if (value === void 0) map.set(key, value = create());
-	return value;
-}
-function indexRun(index, run, entry) {
-	const order = run.text === entry.form ? entry.order : OTHER_FORM_ORDER + entry.order;
-	const reading = {
-		spans: run.spans,
-		weight: entryWeight(entry),
-		tagged: !!entry.priority,
-		order,
-		nf: entry.priority ? entry.nf : 0,
-		jlpt: entry.jlpt ?? 0,
-		tags: priorityTags(entry),
-		tatoeba: entry.tatoeba ?? 0
-	};
-	const readings = getOrCreate(index.runs, run.text, () => /* @__PURE__ */ new Map());
-	const current = readings.get(spanKey(run.spans));
-	if (!current) {
-		readings.set(spanKey(run.spans), reading);
-		return;
+const isJmdict = (reading) => !!(reading.sources & sourceBit("jmdict"));
+const PIN = sourceBit("default");
+function indexRuns(index, runs) {
+	for (const [text, readings] of Object.entries(runs)) {
+		const ranked = [];
+		for (const [furigana, [score, sources]] of Object.entries(readings)) {
+			const spans = parseFurigana(furigana);
+			if (sources & PIN) index.defaults.push({
+				text,
+				spans
+			});
+			if (sources & ~PIN) ranked.push({
+				spans,
+				weight: weightOf(score),
+				score,
+				sources,
+				order: ranked.length
+			});
+		}
+		index.runs.set(text, ranked);
+		if (ranked.some(isJmdict)) index.jmdict.set(text, ranked.filter(isJmdict));
 	}
-	keepBest(current, reading);
-	current.tagged ||= reading.tagged;
-	current.order = Math.min(current.order, reading.order);
-	current.tatoeba = Math.max(current.tatoeba ?? 0, reading.tatoeba);
 }
-function indexSingle(index, run, entry) {
-	const ruby = run.spans[0].ruby;
-	const readings = getOrCreate(index.singles, run.text, () => /* @__PURE__ */ new Map());
-	for (const r of entry.conjugatesReading && ruby === "く" ? [
-		"く",
-		"き",
-		"こ"
-	] : [ruby]) {
-		const value = {
-			weight: entryWeight(entry),
-			nf: entry.nf,
-			jlpt: entry.jlpt ?? 0,
-			tags: priorityTags(entry)
-		};
-		const current = readings.get(r);
-		if (current) keepBest(current, value);
-		else readings.set(r, value);
+function indexKanji(index, kanji) {
+	for (const [text, readings] of Object.entries(kanji)) for (const [ruby, [score, sources]] of Object.entries(readings)) {
+		if (weightOf(score)) getOrCreate(index.singles, text, () => /* @__PURE__ */ new Map()).set(ruby, {
+			weight: weightOf(score),
+			score,
+			sources
+		});
+		if (sources & sourceBit("inflecting")) getOrCreate(index.inflecting, text, () => /* @__PURE__ */ new Set()).add(ruby);
+		if (sources & PIN) index.defaults.push({
+			text,
+			spans: [{
+				start: 0,
+				end: 1,
+				ruby
+			}]
+		});
 	}
 }
-const OKURIGANA = /[\u3041-\u3096]/;
-function indexEntry(index, entry) {
-	for (const run of hanRuns(entry.form, parseFurigana(entry.furigana))) {
-		if (length(run.text) > 1) {
-			indexRun(index, run, entry);
-			continue;
-		}
-		if (entry.tatoeba && !entry.conjugatesReading) {
-			const uses = getOrCreate(index.loneUses, run.text, () => /* @__PURE__ */ new Map());
-			uses.set(run.spans[0].ruby, (uses.get(run.spans[0].ruby) ?? 0) + entry.tatoeba);
-		}
-		if (entry.priority) indexSingle(index, run, entry);
-		else if (OKURIGANA.test(entry.form[entry.form.indexOf(run.text) + run.text.length] ?? "")) getOrCreate(index.inflecting, run.text, () => /* @__PURE__ */ new Set()).add(run.spans[0].ruby);
-	}
+/** The compiled dictionary as the planner looks it up. */
+function indexDictionary(dictionary) {
+	const index = {
+		runs: /* @__PURE__ */ new Map(),
+		jmdict: /* @__PURE__ */ new Map(),
+		singles: /* @__PURE__ */ new Map(),
+		inflecting: /* @__PURE__ */ new Map(),
+		defaults: []
+	};
+	indexRuns(index, dictionary.runs);
+	indexKanji(index, dictionary.kanji);
+	return index;
 }
 function createContext(dictionary, options, coverage) {
 	const covered = (text) => codepoints(text).every((cp) => coverage.has(cp));
@@ -627,20 +1001,22 @@ function createContext(dictionary, options, coverage) {
 		if (options.rubyScript === "katakanaOn" && kanji.length === 1 && isOnyomi(span.ruby, dictionary.onyomi[kanji[0]] ?? [])) return toKatakana(span.ruby);
 		return span.ruby;
 	};
-	const known = options.skipJlpt ? Number(options.skipJlpt.slice(1)) : Infinity;
+	const known = options.skipJlpt ? JLPT_LEVELS.slice(0, JLPT_LEVELS.indexOf(options.skipJlpt) + 1).reduce((mask, level) => mask | sourceBit(level), 0) : 0;
 	return {
 		options,
-		removed: /* @__PURE__ */ new Set([...dictionary.bare ?? [], ...options.words.remove]),
+		removed: /* @__PURE__ */ new Set([...dictionary.bare, ...options.words.remove]),
 		covered,
-		selected: (r) => r.nf >= options.nfMin && r.nf <= options.nfMax || options.selectTags.some((t) => r.tags.has(t)) || options.minTatoeba > 0 && (r.tatoeba ?? 0) >= options.minTatoeba,
-		skipped: (r) => r.nf > 0 && r.nf < options.nfMin || r.jlpt >= known,
+		known: (sources) => !!(sources & known),
 		render,
 		renderable: (run) => covered(run.text) && run.spans.every((_, i) => covered(render(run, i)))
 	};
 }
-function addCustomWord(patterns, lonePins, notation, pinned, ctx) {
+function notationRuns(notation) {
 	const { form, spans } = parseNotation(notation);
-	for (const run of hanRuns(form, spans).filter(ctx.renderable)) {
+	return hanRuns(form, spans);
+}
+function addCustomRuns(patterns, lonePins, runs, pinned, ctx) {
+	for (const run of runs.filter(ctx.renderable)) {
 		if (length(run.text) === 1) {
 			if (pinned) lonePins.set(run.text, run.spans[0].ruby);
 			continue;
@@ -652,101 +1028,69 @@ function addCustomWord(patterns, lonePins, notation, pinned, ctx) {
 		else readings.push({
 			spans: run.spans,
 			weight: 1,
-			tagged: true,
+			score: 100,
+			sources: 0,
 			order: Number.MAX_SAFE_INTEGER,
-			nf: 1,
-			jlpt: 0,
-			tags: /* @__PURE__ */ new Set(),
 			pinned
 		});
 	}
 }
-/** Place names fill the runs no common word claims, nor a skipped one. */
-function addPlaces(patterns, places, skipped, ctx) {
-	for (const place of places ?? []) {
-		const spans = parseFurigana(place.furigana);
-		if (patterns.has(place.form) || skipped.has(place.form) || ctx.removed.has(place.form) || !ctx.renderable({
-			text: place.form,
-			spans
-		})) continue;
-		patterns.set(place.form, [{
-			spans,
-			weight: 0,
-			tagged: false,
-			order: 0,
-			nf: 0,
-			jlpt: 0,
-			tags: /* @__PURE__ */ new Set(),
-			place: true
-		}]);
-	}
-}
-/** Words of the manual sources fill the runs no common word claims, nor a skipped one; they come before place names. */
-function addManual(patterns, manual, skipped, ctx) {
-	const names = ctx.options.manual ?? Object.keys(manual);
-	for (const notation of names.flatMap((name) => manual[name] ?? [])) {
-		const { form, spans } = parseNotation(notation);
-		for (const run of hanRuns(form, spans).filter(ctx.renderable)) {
-			if (length(run.text) === 1 || patterns.has(run.text) || skipped.has(run.text) || ctx.removed.has(run.text)) continue;
-			patterns.set(run.text, [{
-				spans: run.spans,
-				weight: 0,
-				tagged: false,
-				order: 0,
-				nf: 0,
-				jlpt: 0,
-				tags: /* @__PURE__ */ new Set(),
-				place: true
-			}]);
-		}
-	}
-}
-/** Words no list ranks fill the runs nothing else claims, each with its first reading: they are no evidence for the kanji's own. */
-function addUntagged(patterns, index, skipped, ctx) {
-	for (const [text, readings] of index.runs) {
-		if (patterns.has(text) || skipped.has(text) || ctx.removed.has(text)) continue;
-		const first = [...readings.values()].filter((r) => ctx.renderable({
-			text,
-			spans: r.spans
-		})).sort((a, b) => a.order - b.order)[0];
-		if (first) patterns.set(text, [{
-			...first,
-			place: true
-		}]);
-	}
+/** A run's readings from the plan's sources that the font can draw: those the lists or the sentences back, else the first, which is no evidence for its kanji's. */
+function wordReadings(text, readings, wanted, ctx) {
+	const selected = readings.filter((r) => r.sources & wanted && ctx.renderable({
+		text,
+		spans: r.spans
+	}));
+	const backed = selected.filter((r) => r.score > SCORE.used);
+	return backed.length ? backed.map((r) => ({ ...r })) : selected.slice(0, 1).map((r) => ({
+		...r,
+		place: true
+	}));
 }
 /**
-* Runs of common words, then place names and custom words; pinned readings of
-* lone kanji are returned apart. A word is skipped whole: were only its known
-* reading dropped, 今日 would show こんにち.
+* The words of the plan's sources, but those the reader knows, those the
+* user removes and, by score, the `skip` most common, words and lone kanji
+* together; then the `take` next words, and the user's own. A word is skipped
+* whole: were only its known reading dropped, 今日 would show こんにち.
 */
-function selectWords(index, dictionary, ctx) {
-	const patterns = /* @__PURE__ */ new Map();
+function selectWords(index, ctx) {
+	const wanted = ctx.options.sources.reduce((mask, source) => mask | sourceBit(source), 0);
 	const skipped = /* @__PURE__ */ new Set();
+	const skippedKanji = /* @__PURE__ */ new Set();
+	const words = [];
 	for (const [text, readings] of index.runs) {
 		if (ctx.removed.has(text)) continue;
-		if ([...readings.values()].some(ctx.skipped)) {
+		if (readings.some((r) => ctx.known(r.sources))) {
 			skipped.add(text);
 			continue;
 		}
-		const common = [...readings.values()].filter((r) => ctx.selected(r) && ctx.renderable({
-			text,
-			spans: r.spans
-		}));
-		if (common.length) patterns.set(text, common.map((r) => ({ ...r })));
+		const chosen = wordReadings(text, readings, wanted, ctx);
+		if (chosen.length) words.push([text, chosen]);
 	}
-	if (dictionary.manual) addManual(patterns, dictionary.manual, skipped, ctx);
-	if (ctx.options.places) addPlaces(patterns, dictionary.places, skipped, ctx);
-	if (ctx.options.untagged) addUntagged(patterns, index, skipped, ctx);
+	const kanji = [...index.singles].map(([text, readings]) => [text, [...readings.values()].reduce((a, b) => b.score > a.score ? b : a)]);
+	for (const [text] of kanji.filter(([, top]) => ctx.known(top.sources))) skippedKanji.add(text);
+	const byScore = [...words.map(([text, readings]) => ({
+		text,
+		score: Math.max(...readings.map((r) => r.score)),
+		word: true
+	})), ...kanji.filter(([text]) => !skippedKanji.has(text)).map(([text, top]) => ({
+		text,
+		score: top.score,
+		word: false
+	}))].sort((a, b) => b.score - a.score);
+	for (const { text, word } of byScore.slice(0, ctx.options.skip)) (word ? skipped : skippedKanji).add(text);
+	const taken = new Set(byScore.slice(ctx.options.skip).filter((item) => item.word).slice(0, ctx.options.take).map((item) => item.text));
+	const patterns = new Map(words.filter(([text]) => taken.has(text)));
 	const lonePins = /* @__PURE__ */ new Map();
-	for (const notation of ctx.options.words.add) addCustomWord(patterns, lonePins, notation, 0, ctx);
-	for (const notation of dictionary.defaults ?? []) addCustomWord(patterns, lonePins, notation, 1, ctx);
-	for (const notation of ctx.options.words.pin) addCustomWord(patterns, lonePins, notation, 2, ctx);
+	addCustomRuns(patterns, lonePins, ctx.options.words.add.flatMap(notationRuns), 0, ctx);
+	addCustomRuns(patterns, lonePins, index.defaults, 1, ctx);
+	addCustomRuns(patterns, lonePins, ctx.options.words.pin.flatMap(notationRuns), 2, ctx);
 	for (const readings of patterns.values()) readings.sort(rank).splice(15);
 	return {
 		patterns,
 		lonePins,
-		skipped
+		skipped,
+		skippedKanji
 	};
 }
 /** Readings of a lone kanji the font can draw, heaviest first, with their share of the evidence. */
@@ -766,24 +1110,6 @@ function loneReadings(kanji, readings, ctx) {
 		share: r.weight / total
 	})).sort((a, b) => b.weight - a.weight);
 }
-/** The reading running text gives a lone kanji most, with its share of the uses, when the sentences use the kanji alone often enough to tell. */
-function usedReading(kanji, uses, ctx) {
-	const drawable = [...uses ?? []].filter(([ruby]) => ctx.renderable({
-		text: kanji,
-		spans: [{
-			start: 0,
-			end: 1,
-			ruby
-		}]
-	}));
-	const total = drawable.reduce((sum, [, n]) => sum + n, 0);
-	if (ctx.options.minTatoeba === 0 || total < LONE_MIN_USES) return;
-	const [ruby, n] = drawable.sort((a, b) => b[1] - a[1])[0];
-	return {
-		ruby,
-		share: n / total
-	};
-}
 function addWordEvidence(patterns, add) {
 	for (const [text, readings] of patterns) {
 		const chars = [...text];
@@ -803,12 +1129,13 @@ function addRareVerbEvidence(inflecting, ctx, add) {
 }
 /**
 * A kanji alone in its run gets ruby only when one reading clearly dominates
-* the common words it stands alone in, whatever the word list's size: verbs
+* the common words it stands alone in, or the sentences' uses of it alone
+* (ゴミ箱 is common, yet 箱 reads はこ), whatever the word list's size: verbs
 * like 書く rank low in newspapers yet decide how 書 reads. Every kanji also
 * gets an ordered list of its readings, which the variation selectors index
 * into, except a kanji whose dominant reading the reader is taken to know.
 */
-function chooseLoneKanji(index, patterns, lonePins, ctx) {
+function chooseLoneKanji(index, { patterns, lonePins, skippedKanji }, ctx) {
 	const isolated = new Map(ctx.options.isolated ? lonePins : []);
 	const skipped = /* @__PURE__ */ new Set();
 	const evidence = /* @__PURE__ */ new Map();
@@ -821,9 +1148,8 @@ function chooseLoneKanji(index, patterns, lonePins, ctx) {
 		if (ctx.removed.has(kanji)) continue;
 		const ranked = loneReadings(kanji, readings, ctx).filter((r) => r.share >= MIN_ALTERNATE_SHARE);
 		const top = ranked[0];
-		const chosen = usedReading(kanji, index.loneUses.get(kanji), ctx) ?? top;
-		if (top && !lonePins.has(kanji) && ctx.skipped(readings.get(top.ruby))) skipped.add(kanji);
-		else if (chosen && chosen.share >= ctx.options.isolatedMinShare && ctx.options.isolated && !isolated.has(kanji)) isolated.set(kanji, chosen.ruby);
+		if (top && !lonePins.has(kanji) && skippedKanji.has(kanji)) skipped.add(kanji);
+		else if (top && top.share >= ctx.options.isolatedMinShare && ctx.options.isolated && !isolated.has(kanji)) isolated.set(kanji, top.ruby);
 		for (const r of ranked) add(kanji, r.ruby, r.weight);
 	}
 	addWordEvidence(patterns, add);
@@ -854,11 +1180,11 @@ function chooseSuffixes(index, ctx) {
 	const count = (counts, key) => void counts.set(key, (counts.get(key) ?? 0) + 1);
 	const starts = /* @__PURE__ */ new Map();
 	const ends = /* @__PURE__ */ new Map();
-	for (const [text, readings] of index.runs) {
+	for (const [text, readings] of index.jmdict) {
 		const chars = [...text];
 		count(starts, chars[0]);
 		count(ends, chars.at(-1));
-		for (const { spans } of readings.values()) {
+		for (const { spans } of readings) {
 			const span = spans.at(-1);
 			if (span.end - span.start === 1) count(getOrCreate(evidence, chars.at(-1), () => /* @__PURE__ */ new Map()), span.ruby);
 		}
@@ -922,10 +1248,10 @@ function findMisreadRuns(index, patterns, kanjiReadings, suffixes, skipped, ctx)
 	}
 	const protect = (text, readings, longest) => {
 		const chars = [...text];
-		const candidates = [...new Set([...readings.values()].map((r) => assignment(r.spans, chars.length).join("|")))];
-		const expected = [...readings.values()].map((r) => assignment(r.spans, chars.length));
+		const candidates = [...new Set(readings.map((r) => assignment(r.spans, chars.length).join("|")))];
+		const expected = readings.map((r) => assignment(r.spans, chars.length));
 		if (!expected.some((e) => misreads(chars, e, known, longest, suffixes))) return false;
-		const truth = [...readings.values()].sort(rank)[0];
+		const truth = readings.toSorted(rank)[0];
 		const run = {
 			text,
 			spans: truth.spans
@@ -939,7 +1265,7 @@ function findMisreadRuns(index, patterns, kanjiReadings, suffixes, skipped, ctx)
 		let longest = 2;
 		for (const text of known.keys()) longest = Math.max(longest, length(text));
 		changed = false;
-		for (const [text, readings] of index.runs) if (!known.has(text) && ctx.covered(text) && protect(text, readings, longest)) changed = true;
+		for (const [text, readings] of index.jmdict) if (!known.has(text) && ctx.covered(text) && protect(text, readings, longest)) changed = true;
 	}
 	return protectedRuns;
 }
@@ -1064,7 +1390,7 @@ function buildRules(patterns, kanjiReadings, protectedRuns, glyphs) {
 	};
 }
 function smokeChecks(patterns, lone, glyphs) {
-	const byFrequency = [...patterns].sort((a, b) => (a[1][0].nf || 99) - (b[1][0].nf || 99));
+	const byFrequency = [...patterns].sort((a, b) => b[1][0].score - a[1][0].score);
 	const checks = [];
 	for (const grouped of [false, true]) for (const [text, readings] of byFrequency.filter(([text, r]) => isGrouped({
 		text,
@@ -1094,24 +1420,19 @@ function smokeChecks(patterns, lone, glyphs) {
 	return checks;
 }
 /**
-* Indexes the dictionary once into Han runs, then plans fonts from it. Every
+* Indexes the compiled dictionary once, then plans fonts from it. Every
 * decision about readings happens here: which words get ruby, which reading
 * is the default, which longer words must be protected from a shorter match.
 */
 function createFontPlanner(dictionary) {
-	const index = {
-		runs: /* @__PURE__ */ new Map(),
-		singles: /* @__PURE__ */ new Map(),
-		inflecting: /* @__PURE__ */ new Map(),
-		loneUses: /* @__PURE__ */ new Map()
-	};
-	for (const entry of dictionary.entries) indexEntry(index, entry);
-	const sources = Object.entries(dictionary.sources).map(([name, version]) => `${name} ${version}`).join(", ");
+	const index = indexDictionary(dictionary);
+	const sources = Object.entries(dictionary.versions).map(([name, version]) => `${name} ${version}`).join(", ");
 	/** Every decision for one set of options, over the whole dictionary: slow, and the same whatever the preview text. */
 	function analyze(options, coverage) {
 		const ctx = createContext(dictionary, options, coverage);
-		const { patterns, lonePins, skipped } = selectWords(index, dictionary, ctx);
-		const { isolated, kanjiReadings } = chooseLoneKanji(index, patterns, lonePins, ctx);
+		const selection = selectWords(index, ctx);
+		const { patterns, skipped } = selection;
+		const { isolated, kanjiReadings } = chooseLoneKanji(index, selection, ctx);
 		const suffixes = chooseSuffixes(index, ctx);
 		const protectedRuns = findMisreadRuns(index, patterns, kanjiReadings, suffixes, skipped, ctx);
 		const glyphs = createGlyphRegistry(ctx.render);
@@ -1246,148 +1567,4 @@ function createFontPlanner(dictionary) {
 	};
 }
 //#endregion
-//#region src/schema.ts
-const RUBY_SCRIPTS = [
-	"hiragana",
-	"katakanaOn",
-	"hepburn"
-];
-const PRIORITY_TAGS = [
-	"ichi1",
-	"ichi2",
-	"news1",
-	"news2",
-	"spec1",
-	"spec2",
-	"gai1",
-	"gai2"
-];
-/** Easiest first. */
-/** The dictionary's manually maintained sources, which a plan may include by name. */
-const MANUAL_SOURCES = [
-	"mahjong-yaku",
-	"jr-stations",
-	"yojijukugo"
-];
-const JLPT_LEVELS = [
-	"N5",
-	"N4",
-	"N3",
-	"N2",
-	"N1"
-];
-/** Sizes in em, relative to the base font. */
-const RubyMetricsSchema = v.object({
-	/** Ruby size relative to the base characters. */
-	rubyScale: v.optional(v.pipe(v.number(), v.minValue(.2), v.maxValue(.8)), DEFAULTS.plan.metrics.rubyScale),
-	/** Space between the top of the em box and the bottom of the ruby. */
-	rubyGap: v.optional(v.pipe(v.number(), v.minValue(0), v.maxValue(.5)), DEFAULTS.plan.metrics.rubyGap),
-	/** Ruby is squeezed horizontally down to this scale before it may overhang. */
-	compressionFloor: v.optional(v.pipe(v.number(), v.minValue(.3), v.maxValue(1)), DEFAULTS.plan.metrics.compressionFloor),
-	/** Widest a ruby may get, overhanging its base symmetrically. */
-	maxRubyWidth: v.optional(v.pipe(v.number(), v.minValue(1), v.maxValue(3)), DEFAULTS.plan.metrics.maxRubyWidth)
-});
-const Bucket = v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(48));
-/** `schema`, checking that its frequency window `nfMin..nfMax` holds a bucket; for schemas that extend the options too. */
-function withNfWindow(schema) {
-	return v.pipe(schema, v.check((o) => o.nfMin <= o.nfMax, "nfMin must not exceed nfMax"));
-}
-const PlanOptionsSchema = withNfWindow(v.object({
-	family: v.optional(v.pipe(v.string(), v.trim(), v.nonEmpty(), v.check((name) => !/source/i.test(name), "Source is a reserved font name of the base font")), DEFAULTS.plan.family),
-	rubyScript: v.optional(v.picklist(RUBY_SCRIPTS), DEFAULTS.plan.rubyScript),
-	/**
-	* Words whose newspaper frequency bucket is below this stay bare: the most
-	* common ones, which a reader knows. Tags don't bring them back.
-	*/
-	nfMin: v.optional(Bucket, DEFAULTS.plan.nfMin),
-	/** Words whose newspaper frequency bucket is at most this are annotated. */
-	nfMax: v.optional(Bucket, DEFAULTS.plan.nfMax),
-	/**
-	* JMdict priority tags that select a word whatever its frequency bucket:
-	* `spec1` catches words like 日本 that the newspaper ranking misses.
-	*/
-	selectTags: v.optional(v.array(v.picklist(PRIORITY_TAGS)), () => [...DEFAULTS.plan.selectTags]),
-	/**
-	* Words of two or more kanji that Tatoeba's example sentences use at least
-	* this many times are annotated whatever their bucket: everyday words that
-	* no list tags, such as 留守中, which would otherwise be bare or read as a
-	* place name (国中 くになか, not くにじゅう). The sentences also decide how a
-	* lone kanji reads, where they use it alone often enough. 0 turns them off.
-	*/
-	minTatoeba: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0)), DEFAULTS.plan.minTatoeba),
-	/** Words on the JLPT lists of this level and every easier one stay bare. */
-	skipJlpt: v.optional(v.picklist(JLPT_LEVELS)),
-	/** Annotate place names from the dictionary where no common word claims the run. */
-	places: v.optional(v.boolean(), DEFAULTS.plan.places),
-	/** Annotate the words of JMdict that no list ranks or tags (such as 四字熟語), where no common word, manual list or place name claims the run; each gets its first reading. */
-	untagged: v.optional(v.boolean(), DEFAULTS.plan.untagged),
-	/** The dictionary's manually maintained sources (such as `mahjong-yaku`) to annotate; all of them when left out. */
-	manual: v.optional(v.array(v.picklist(MANUAL_SOURCES))),
-	/** Annotate a kanji alone in its run, or one no word claims after another kanji (a suffix); when off, only selectors give them ruby. */
-	isolated: v.optional(v.boolean(), DEFAULTS.plan.isolated),
-	/** A kanji alone in its run is annotated only when one reading has this share of the evidence. */
-	isolatedMinShare: v.optional(v.pipe(v.number(), v.minValue(.5), v.maxValue(1)), DEFAULTS.plan.isolatedMinShare),
-	words: v.optional(v.object({
-		/** Extra words in inline notation, `日[に]本[ほん]`. */
-		add: v.optional(v.array(v.string()), []),
-		/** Written forms never to annotate. */
-		remove: v.optional(v.array(v.string()), []),
-		/** Readings to make the default, in inline notation. */
-		pin: v.optional(v.array(v.string()), [])
-	}), {}),
-	metrics: v.optional(RubyMetricsSchema, {})
-}));
-function resolveOptions(input = {}) {
-	return v.parse(PlanOptionsSchema, input);
-}
-const Codepoint = v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(1114111));
-/**
-* The contract between the planner and the compiler. The compiler makes no
-* decision about readings: it draws what `glyphs` describes and compiles `fea`.
-* In `fea`, base characters are named `uniXXXX` / `uXXXXX` after their codepoint.
-*/
-const PlanSchema = v.object({
-	version: v.literal(1),
-	names: v.object({
-		family: v.string(),
-		description: v.string()
-	}),
-	metrics: v.object({
-		rubyScale: v.number(),
-		rubyGap: v.number(),
-		compressionFloor: v.number(),
-		maxRubyWidth: v.number()
-	}),
-	/** Base characters the rules name; each must be in the base font's cmap. */
-	codepoints: v.array(Codepoint),
-	/**
-	* Base + variation selector sequences to map in `cmap` format 14, each to an
-	* empty glyph named `name`, with the base's advance: the rules replace it.
-	*/
-	variants: v.array(v.object({
-		name: v.pipe(v.string(), v.regex(/^[A-Z_][\w.]{0,62}$/i)),
-		base: Codepoint,
-		selector: Codepoint
-	})),
-	glyphs: v.array(v.object({
-		name: v.pipe(v.string(), v.regex(/^[A-Z_][\w.]{0,62}$/i)),
-		/** The base characters drawn side by side; more than one makes a ligature. */
-		bases: v.pipe(v.array(Codepoint), v.minLength(1)),
-		/** Ruby text drawn above characters `[start, end)` of `bases`. */
-		ruby: v.array(v.object({
-			start: v.number(),
-			end: v.number(),
-			text: v.pipe(v.string(), v.nonEmpty())
-		}))
-	})),
-	fea: v.string(),
-	/** Subset the base font to these codepoints before building (live previews). */
-	subset: v.optional(v.array(Codepoint)),
-	/** Shaping checks the compiler runs on its output: `text` must shape to `glyphs`. */
-	smoke: v.array(v.object({
-		text: v.string(),
-		glyphs: v.array(v.string())
-	}))
-});
-//#endregion
-export { DEFAULTS, JLPT_LEVELS, MANUAL_SOURCES, MAX_READINGS, PREBUILT, PRIORITY_TAGS, PlanOptionsSchema, PlanSchema, RUBY_SCRIPTS, SELECTOR_FIRST_READING, SELECTOR_SUPPRESS, VERSION_PROBE, createFontPlanner, formatNotation, glyphName, hanRuns, isHan, isOnyomi, parseFurigana, parseNotation, resolveOptions, toHepburn, toHiragana, toKatakana, withNfWindow };
+export { DEFAULTS, DictionarySchema, JLPT_LEVELS, MANUAL_SOURCES, MAX_READINGS, PREBUILT, PlanOptionsSchema, PlanSchema, RUBY_SCRIPTS, SCORE, SELECTOR_FIRST_READING, SELECTOR_SUPPRESS, SOURCES, VERSION_PROBE, WORD_SOURCES, createFontPlanner, formatDictionary, formatFurigana, formatNotation, fuseDictionary, glyphName, hanRuns, isHan, isOnyomi, parseFurigana, parseNotation, resolveOptions, scoreOf, sourceBit, sourcesIn, toHepburn, toHiragana, toKatakana, weightOf };