@mailwoman/kind-classifier 10.0.0 → 10.1.0

package/lib/rules.ts

@@ -3,66 +3,57 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Rule-based classifiers for each `QueryKind`. Each rule inspects the normalized input + QueryShape
- *   and returns a confidence score in [0, 1], or 0 if the rule doesn't fire.
- *
- *   Bitter-lesson-safe: only universal structural patterns — no place-name dictionaries. ~1 small
- *   regex set per new locale, not 50K dictionary entries.
+ *   Rule-based `QueryKind` scorers. Each scorer reads structural patterns in the normalized input and
+ *   its QueryShape and returns a confidence from 0 to 1.
  */
 
-import { NAME_PRONE_US_SUFFIXES, US_STREET_SUFFIX_LOOKUP } from "@mailwoman/codex/us/street-suffix"
+import { NAME_PRONE_US_SUFFIXES, US_STREET_SUFFIX_LOOKUP } from "@mailwoman/codex/us/street/suffix"
 import type { NormalizedInputLite, QueryShapeSegmentsView as QueryShapeLike } from "@mailwoman/query-shape"
+import { classifyTokens, foldInputClass } from "@mailwoman/query-shape/character-class"
 import { isPostcodeFormat } from "@mailwoman/query-shape/known-formats"
 /**
- * Longest input still plausible as a bare venue or landmark name. Beyond it the query is carrying an address as well,
- * and belongs to the structured-address scorer.
+ * Maximum length for a bare venue or landmark query.
  */
 const MAX_LANDMARK_LENGTH = 50
 
 /**
- * Longest input still plausible as a bare postcode, allowing for a country prefix and separators.
+ * Maximum length for a bare postcode, including an optional country prefix and separators.
  */
 const MAX_POSTCODE_ONLY_LENGTH = 16
 
 /**
- * Share of the input the postcode must occupy before `postcode_only` fires. Below it the query is carrying something
- * else too — a locality, a street — and another kind should win.
+ * Minimum fraction of the input that a postcode must cover for `postcode_only`.
  */
 const MIN_POSTCODE_COVERAGE = 0.7
 
 /**
- * Longest input still plausible as a bare locality name, including a trailing region code.
- *
- * Exported so `intent-rules.ts`'s `bare_toponym` can share the exact same ceiling. Sharing it is what makes
- * "bare_toponym is a strict refinement of locality_only" a structural property rather than two numbers that happen to
- * agree today.
+ * Maximum length for a bare locality.
+ * The `bare_toponym` intent rule uses the same limit.
  */
 export const MAX_LOCALITY_ONLY_LENGTH = 30
 
 /**
- * Word count of a short capitalized phrase — the shape of a venue name like `Empire State Building`. Wider than this
- * and the phrase is more likely a full address line.
+ * Minimum word count for a short venue phrase.
  */
 const VENUE_PHRASE_MIN_WORDS = 2
 
 /**
- * Upper bound of the short-phrase venue window; see {@link VENUE_PHRASE_MIN_WORDS}.
+ * Maximum word count for a short venue phrase.
  */
 const VENUE_PHRASE_MAX_WORDS = 4
 
 /**
- * Word count above which a single-segment proper-case phrase stops reading as a venue name.
+ * Maximum word count for a longer single-segment venue phrase.
  */
 const LONG_VENUE_PHRASE_MAX_WORDS = 6
 
 /**
- * Length at which a single-segment alphanumeric input reads as a full postcode rather than a fragment. Shorter
- * alphanumeric inputs score lower because they are as likely to be a unit number.
+ * Length at which single-segment alphanumeric input scores as a likely structured address.
  */
 const ALPHANUMERIC_POSTCODE_MIN_LENGTH = 15
 
 /**
- * Landmark vocabulary — phrases that suggest a vague-location description rather than an address.
+ * Phrases that signal a relative landmark description.
  */
 const LANDMARK_LEADERS = [
 	"behind",
@@ -77,32 +68,30 @@ const LANDMARK_LEADERS = [
 ]
 
 /**
- * Intersection vocabulary — words that signal "where two streets cross" rather than an address.
+ * Patterns that signal a street intersection.
  */
 const INTERSECTION_PATTERNS = [
 	/\bcorner of\b/i,
 	/\bintersection of\b/i,
 	/\bat the corner of\b/i,
-	// "5th and Main", "Broadway & 42nd"
+	// Examples: "5th and Main", "Broadway & 42nd".
 	/\b\w+(?:st|nd|rd|th|street|ave|avenue|blvd|boulevard|road|rd|lane|ln)?\s+(?:and|&|@)\s+\w+/i,
 ]
 
 /**
- * `po_box` rule: high-confidence iff QueryShape detected a po_box format hit. Confidence comes directly from the hit;
- * covers all locale variants (US "PO Box 123", FR "BP 42", etc.).
+ * Scores input in which QueryShape detected a PO Box format.
  */
 export function scorePoBox(_input: NormalizedInputLite, shape: QueryShapeLike): number {
 	const hit = shape.knownFormats.find((f) => f.format === "po_box")
 
 	if (!hit) return 0
 
-	// Boost slightly above the raw hit confidence so po_box wins ties with structured_address when
-	// both rules fire on the same input.
+	// The bonus makes a PO Box win a tie with a structured address.
 	return Math.min(1, hit.confidence + 0.1)
 }
 
 /**
- * `intersection` rule: text matches one of the conventional intersection phrasings.
+ * Scores street-intersection phrasing.
  */
 export function scoreIntersection(input: NormalizedInputLite, _shape: QueryShapeLike): number {
 	const text = input.normalized
@@ -115,8 +104,7 @@ export function scoreIntersection(input: NormalizedInputLite, _shape: QueryShape
 }
 
 /**
- * `landmark` rule: text begins with a landmark-leader phrase. These inputs are not addresses proper — they describe a
- * location relative to another place.
+ * Scores input that begins with a relative-landmark phrase.
  */
 export function scoreLandmark(input: NormalizedInputLite, _shape: QueryShapeLike): number {
 	const lc = input.normalized.toLowerCase().trim()
@@ -129,19 +117,14 @@ export function scoreLandmark(input: NormalizedInputLite, _shape: QueryShapeLike
 }
 
 /**
- * Split on whitespace + commas and drop empty words — the word grammar shared with `intent-rules.ts`. Dropping empties
- * matters: a trailing comma or doubled separator otherwise yields an empty string that inflates the word count and
- * falsifies every-word predicates like the proper-case check below.
+ * Splits text on whitespace and commas and drops empty tokens.
  */
 export function wordsOf(text: string): string[] {
-	return text.split(/[\s,]+/).filter((word) => word.length > 0)
+	return text.split(/[\s,]+/).filter((word) => word.length)
 }
 
 /**
- * True when a word is USPS street-suffix vocabulary that unambiguously signals an address — the full Pub-28 table via
- * `@mailwoman/codex`, minus its curated name-prone canonicals (PARK, FIELD, HILL, LAKE, …). Those double as ordinary
- * proper-name heads ("Wrigley Field", "Menlo Park"), and disqualifying on them would reject the very venue and place
- * names the rules below exist to capture. Shared with `intent-rules.ts` so both rule sets read one definition.
+ * Reports whether a word is a USPS street suffix that rarely appears in place names.
  */
 export function isDisqualifyingStreetSuffix(word: string): boolean {
 	const canonical = US_STREET_SUFFIX_LOOKUP.get(word.trim().toLowerCase())
@@ -150,11 +133,80 @@ export function isDisqualifyingStreetSuffix(word: string): boolean {
 }
 
 /**
- * `landmark` rule (venue/named-place variant): short capitalized input with no street suffixes, no postcode hits, and
- * no region abbreviations. Captures "Pier 39", "Empire State Building", "Wrigley Field", "Grand Central Terminal".
+ * Removes postcode spans in the final segment and collapses the remaining separators.
+ */
+export function withoutPostcodeSpans(text: string, shape: QueryShapeLike): string {
+	const merged = mergedPostcodeSpans(shape)
+
+	if (!merged.length) return text
+
+	let remainder = text
+
+	// The loop removes spans from last to first.
+	// This order keeps the remaining offsets valid.
+	for (let index = merged.length - 1; index >= 0; index--) {
+		const span = merged[index]!
+
+		remainder = remainder.slice(0, span.start) + remainder.slice(span.end)
+	}
+
+	return remainder
+		.replaceAll(/[\s,]+/gu, " ")
+		.replace(/[\s,]+$/u, "")
+		.trim()
+}
+
+/**
+ * Reports whether text contains a Unicode letter.
  *
- * Fires at moderate confidence (0.65) — below structured_address (0.9) so addresses always win, but above vague (0.3)
- * so the pipeline can route landmark queries to the venue resolver.
+ * By itself, the `alpha` character class can match punctuation-only input.
+ */
+export function carriesLetter(text: string): boolean {
+	return /\p{L}/u.test(text)
+}
+
+/**
+ * Merges overlapping postcode hits in the final segment into sorted, disjoint spans.
+ */
+function mergedPostcodeSpans(shape: QueryShapeLike): Array<{ start: number; end: number }> {
+	// Postcode hits in earlier segments are often house numbers.
+	const tail = shape.segments?.at(-1)?.span
+
+	if (!tail) return []
+
+	const merged: Array<{ start: number; end: number }> = []
+
+	for (const hit of shape.knownFormats) {
+		if (!isPostcodeFormat(hit.format)) continue
+
+		if (hit.span.start < tail.start || hit.span.end > tail.end) continue
+
+		merged.push({ start: hit.span.start, end: hit.span.end })
+	}
+
+	if (merged.length < 2) return merged
+
+	merged.sort((left, right) => left.start - right.start)
+
+	const disjoint: Array<{ start: number; end: number }> = [merged[0]!]
+
+	for (const span of merged.slice(1)) {
+		const last = disjoint.at(-1)!
+
+		if (span.start <= last.end) {
+			last.end = Math.max(last.end, span.end)
+
+			continue
+		}
+
+		disjoint.push(span)
+	}
+
+	return disjoint
+}
+
+/**
+ * Scores short capitalized venue names that have no street suffix or recognized format.
  */
 export function scoreVenueLandmark(input: NormalizedInputLite, shape: QueryShapeLike): number {
 	const text = input.normalized.trim()
@@ -162,34 +214,28 @@ export function scoreVenueLandmark(input: NormalizedInputLite, shape: QueryShape
 
 	if (len === 0 || len > MAX_LANDMARK_LENGTH) return 0
 
-	// Must have at least one capitalized word.
 	if (!/[A-Z]/.test(text)) return 0
 
-	// Reject if any known postcode format hit exists.
 	if (shape.knownFormats.length) return 0
 
-	// Reject if it looks like a multi-segment structured address (City, ST ZIP).
 	const segCount = shape.segments?.length ?? 1
 
 	if (segCount > 2) return 0
 
-	// Reject if any word is an unambiguous street suffix.
 	const words = wordsOf(text)
 
 	for (const w of words) {
 		if (isDisqualifyingStreetSuffix(w)) return 0
 	}
 
-	// Reject if the first token is a pure number (house-number-leading pattern).
+	// A leading number usually is a house number.
 	if (/^\d+\s/.test(text)) return 0
 
-	// Boost if the input has a number NOT at the start (venue-style: "Pier 39", "Terminal 5").
+	// Venue names often contain a number after the first word.
 	const hasInternalNumber = /\s\d+/.test(text) && !/^\d/.test(text)
 
-	// Check if every word starts with uppercase (proper-noun pattern).
 	const allProperCase = words.length > 1 && words.every((w) => /^[A-Z]/.test(w))
 
-	// Boost for short single-segment capitalized phrases (2-4 words).
 	const wordCount = words.length
 
 	if (wordCount >= VENUE_PHRASE_MIN_WORDS && wordCount <= VENUE_PHRASE_MAX_WORDS && segCount === 1) {
@@ -200,7 +246,6 @@ export function scoreVenueLandmark(input: NormalizedInputLite, shape: QueryShape
 		return 0.65
 	}
 
-	// Longer single-segment capitalized phrases get moderate confidence.
 	if (wordCount <= LONG_VENUE_PHRASE_MAX_WORDS && segCount === 1 && allProperCase) {
 		return 0.75
 	}
@@ -209,10 +254,7 @@ export function scoreVenueLandmark(input: NormalizedInputLite, shape: QueryShape
 }
 
 /**
- * `postcode_only` rule: input is short AND has a postcode format hit covering most of it.
- *
- * The "covering most of it" check is what distinguishes `"10118"` (postcode-only) from `"350 5th Ave 10118"`
- * (structured-address with a postcode in it).
+ * Scores short input in which a postcode covers most of the text.
  */
 export function scorePostcodeOnly(input: NormalizedInputLite, shape: QueryShapeLike): number {
 	const len = input.normalized.length
@@ -223,29 +265,49 @@ export function scorePostcodeOnly(input: NormalizedInputLite, shape: QueryShapeL
 	if (!postcodeHit) return 0
 	const hitLen = postcodeHit.span.end - postcodeHit.span.start
 
-	// At least 70% of the input must be the postcode for the rule to fire confidently.
 	if (hitLen / len < MIN_POSTCODE_COVERAGE) return 0
 
-	// Confidence scales with how much of the input is the postcode and how confident the format hit was.
 	return Math.min(1, postcodeHit.confidence * (hitLen / len) + 0.1)
 }
 
 /**
- * `locality_only` rule: short input, alpha-class, single segment, no format hits.
- *
- * Examples: `"Paris"`, `"NYC NY"`, `"Tokyo"`. Distinguishes from `structured_address` (multiple segments) and `vague`
- * (long or mixed-class).
+ * Scores a place name with at most an administrative tail and an optional postcode.
  */
 export function scoreLocalityOnly(input: NormalizedInputLite, shape: QueryShapeLike): number {
-	const len = input.normalized.length
+	// Any recognized format other than a postcode rules out a bare locality.
+	let carriesPostcode = false
+
+	for (const hit of shape.knownFormats) {
+		if (isPostcodeFormat(hit.format)) {
+			carriesPostcode = true
+
+			continue
+		}
+
+		return 0
+	}
+
+	// Only postcode hits in the final segment can be removed.
+	const removable = carriesPostcode ? mergedPostcodeSpans(shape) : []
+
+	if (carriesPostcode && !removable.length) return 0
+
+	const withoutPostcode = carriesPostcode ? withoutPostcodeSpans(input.normalized, shape) : input.normalized
+	const len = withoutPostcode.length
 
 	if (len === 0 || len > MAX_LOCALITY_ONLY_LENGTH) return 0
 
-	if (shape.characterClass !== "alpha") return 0
+	if (!carriesLetter(withoutPostcode)) return 0
 
-	if (shape.knownFormats.length) return 0
-	// Locality-only inputs typically have 1-3 segments (e.g. "New York" is 1 segment, "Paris, FR" is 2).
-	// We allow up to 2 segments before deciding it's structured.
+	// The remaining text must be alphabetic.
+	// Its class is recomputed only after a postcode was removed.
+	if (shape.characterClass !== "alpha") {
+		if (!carriesPostcode) return 0
+
+		if (foldInputClass(classifyTokens(withoutPostcode)) !== "alpha") return 0
+	}
+
+	// A locality and an administrative tail use at most two segments.
 	const segCount = shape.segments?.length ?? 1
 
 	if (segCount > 2) return 0
@@ -254,8 +316,7 @@ export function scoreLocalityOnly(input: NormalizedInputLite, shape: QueryShapeL
 }
 
 /**
- * `structured_address` rule: looks like a real multi-component address. Either has multiple segments or is long and
- * mixed-class.
+ * Scores multi-component address shapes.
  */
 export function scoreStructuredAddress(input: NormalizedInputLite, shape: QueryShapeLike): number {
 	const len = input.normalized.length
@@ -263,26 +324,27 @@ export function scoreStructuredAddress(input: NormalizedInputLite, shape: QueryS
 	if (len === 0) return 0
 	const segCount = shape.segments?.length ?? 1
 
-	// Multi-segment input with mixed character class = high confidence structured.
-	if (segCount >= 2 && shape.characterClass === "alphanumeric") return 0.9
+	// Digits outside the postcode are required, so a locality with a postcode does not score here.
+	if (
+		segCount >= 2 &&
+		shape.characterClass === "alphanumeric" &&
+		/\d/u.test(withoutPostcodeSpans(input.normalized, shape))
+	) {
+		return 0.9
+	}
 
-	// Single-segment but reasonably long and alphanumeric = moderate confidence.
 	if (len >= ALPHANUMERIC_POSTCODE_MIN_LENGTH && shape.characterClass === "alphanumeric") return 0.75
 
-	// Multi-segment but pure-alpha = moderate (could be a multi-word locality).
+	// Multi-segment input without digits may still be a multi-word locality, so it scores lower.
 	if (segCount >= 2) return 0.6
 
-	// Single-segment, short, alphanumeric (e.g. "10118-1234" with no other content) — weak.
 	if (len < ALPHANUMERIC_POSTCODE_MIN_LENGTH && shape.characterClass === "alphanumeric") return 0.4
 
 	return 0
 }
 
 /**
- * `vague` rule: nothing else fired with high confidence — input is ambiguous.
- *
- * Returns a moderate baseline so `vague` always shows up as an alternative, even when other rules dominate. The
- * coordinator decides whether to trust vague as the primary kind.
+ * Returns a low constant fallback score for ambiguous input.
  */
 export function scoreVague(_input: NormalizedInputLite, _shape: QueryShapeLike): number {
 	return 0.3

package/out/classify.d.ts

@@ -3,30 +3,25 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   `classifyKind` — entry point for Stage 2.5 (kind classification).
+ * `classifyKind` is the entry point for Stage 2.5 (kind classification), composing the per-kind rules
+ * from `rules.ts` and `intent-rules.ts` and returning alternatives sorted by confidence.
  *
- *   Composes the per-kind rules from `rules.ts` and `intent-rules.ts` and picks the winner. Returns
- *   alternatives sorted by confidence so the coordinator can offer fallback paths when the top kind
- *   isn't actionable.
- *
- *   Per the project's "possibilities not constraints" principle, every kind that fires above 0
- *   surfaces in `alternatives` — the caller decides whether to act on the top kind only or consider
- *   runner-ups. The ROAD_TO_V9 §4 intent vocabulary leans on that: `bare_toponym` and `route_pair`
- *   are scored below their structural incumbent precisely so they land in `alternatives`, where they
- *   inform the markers without moving the routing decision.
+ * Per the project's "possibilities not constraints" principle, every kind that fires above 0 surfaces
+ * in `alternatives` and the caller decides whether to act on the top kind only: `bare_toponym` and
+ * `route_pair` are scored below their structural incumbent precisely so they land in `alternatives`,
+ * where they inform the markers without moving the routing decision.
  */
 import type { LocaleHint, QueryKindResult } from "@mailwoman/core/pipeline";
 import type { NormalizedInputLite, QueryShapeSegmentsView as QueryShapeLike } from "@mailwoman/query-shape";
 import { type POIPhraseLookup } from "#poi";
 /**
- * Classify the query shape into a `QueryKind`. Synchronous + pure — produces the same result for the same `(input,
- * shape)` pair.
+ * Classify the query shape into a `QueryKind`, synchronously and purely,
+ * producing the same result for the same `(input, shape)` pair.
  */
 export declare function classifyKindSync(input: NormalizedInputLite, shape: QueryShapeLike): QueryKindResult;
 /**
- * Async variant matching the runtime-pipeline's `classifyKind` contract.
- *
- * The locale parameter is accepted for future locale-aware rules (Japanese honorifics, etc.) but not currently used.
+ * Async variant matching the runtime pipeline's `classifyKind` interface;
+ * `_locale` is accepted for future locale-aware rules but currently unused.
  */
 export declare function classifyKind(input: NormalizedInputLite, shape: QueryShapeLike, _locale?: LocaleHint): Promise<QueryKindResult>;
 /**
@@ -34,15 +29,18 @@ export declare function classifyKind(input: NormalizedInputLite, shape: QuerySha
  */
 export interface KindClassifierOpts {
     /**
-     * POI phrase lexicon (spec §3.1). When present, `poi_query` and `poi_category` scorers join the rule set — injected,
-     * never imported, so this package stays dictionary-free. Absent → the returned classifier is behaviorally identical
-     * to {@link classifyKind}.
+     * POI phrase lexicon (spec §3.1); when present the `poi_query`
+     * and `poi_category` scorers join the rule set.
+     *
+     * They are injected rather than imported so this package stays dictionary-free.
+     * When absent, the returned classifier behaves identically to {@link classifyKind}.
      */
     poiLexicon?: POIPhraseLookup;
 }
 /**
- * Build a kind classifier. Without opts this is exactly the default {@link classifyKind}; with a `poiLexicon` it
- * additionally scores `poi_query` + `poi_category` (ROAD_TO_V9 §4.4) and merges them into the ranked result.
+ * Build a kind classifier that is exactly {@link classifyKind} without options,
+ * or that additionally scores `poi_query` + `poi_category` (ROAD_TO_V9 §4.4)
+ * and merges them into the ranked result when given a `poiLexicon`.
  */
 export declare function createKindClassifier(opts?: KindClassifierOpts): (input: NormalizedInputLite, shape: QueryShapeLike, locale?: LocaleHint) => Promise<QueryKindResult>;
 //# sourceMappingURL=classify.d.ts.map

package/out/classify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../lib/classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAgC,eAAe,EAAE,MAAM,0BAA0B,CAAA;AACzG,OAAO,KAAK,EAAE,mBAAmB,EAAE,sBAAsB,IAAI,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAI3G,OAAO,EAA+C,KAAK,eAAe,EAAE,MAAM,MAAM,CAAA;AA4ExF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,cAAc,GAAG,eAAe,CAMnG;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CACjC,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,cAAc,EACrB,OAAO,CAAC,EAAE,UAAU,GAClB,OAAO,CAAC,eAAe,CAAC,CAE1B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;;OAIG;IACH,UAAU,CAAC,EAAE,eAAe,CAAA;CAC5B;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,GAAE,kBAAuB,GAC3B,CAAC,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,UAAU,KAAK,OAAO,CAAC,eAAe,CAAC,CA+BtG"}
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../lib/classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAgC,eAAe,EAAE,MAAM,0BAA0B,CAAA;AACzG,OAAO,KAAK,EAAE,mBAAmB,EAAE,sBAAsB,IAAI,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAI3G,OAAO,EAA+C,KAAK,eAAe,EAAE,MAAM,MAAM,CAAA;AA4ExF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,cAAc,GAAG,eAAe,CAMnG;AAED;;;GAGG;AACH,wBAAsB,YAAY,CACjC,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,cAAc,EACrB,OAAO,CAAC,EAAE,UAAU,GAClB,OAAO,CAAC,eAAe,CAAC,CAE1B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,eAAe,CAAA;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,GAAE,kBAAuB,GAC3B,CAAC,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,UAAU,KAAK,OAAO,CAAC,eAAe,CAAC,CAgCtG"}

package/out/classify.js

@@ -3,17 +3,13 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   `classifyKind` — entry point for Stage 2.5 (kind classification).
+ * `classifyKind` is the entry point for Stage 2.5 (kind classification), composing the per-kind rules
+ * from `rules.ts` and `intent-rules.ts` and returning alternatives sorted by confidence.
  *
- *   Composes the per-kind rules from `rules.ts` and `intent-rules.ts` and picks the winner. Returns
- *   alternatives sorted by confidence so the coordinator can offer fallback paths when the top kind
- *   isn't actionable.
- *
- *   Per the project's "possibilities not constraints" principle, every kind that fires above 0
- *   surfaces in `alternatives` — the caller decides whether to act on the top kind only or consider
- *   runner-ups. The ROAD_TO_V9 §4 intent vocabulary leans on that: `bare_toponym` and `route_pair`
- *   are scored below their structural incumbent precisely so they land in `alternatives`, where they
- *   inform the markers without moving the routing decision.
+ * Per the project's "possibilities not constraints" principle, every kind that fires above 0 surfaces
+ * in `alternatives` and the caller decides whether to act on the top kind only: `bare_toponym` and
+ * `route_pair` are scored below their structural incumbent precisely so they land in `alternatives`,
+ * where they inform the markers without moving the routing decision.
  */
 import { deriveIntentMarkers } from "#intent/markers";
 import { scoreBareToponym, scoreNearMe, scoreRoutePair } from "#intent/rules";
@@ -26,17 +22,17 @@ const SCORERS = [
     { kind: "postcode_only", score: scorePostcodeOnly },
     { kind: "locality_only", score: scoreLocalityOnly },
     { kind: "structured_address", score: scoreStructuredAddress },
-    // ROAD_TO_V9 §4. Ordinary members of the same list — intent is vocabulary, not a stage. `bare_toponym` and
-    // `route_pair` are scored under `locality_only` on purpose (see `intent-rules.ts`), so their position here is
-    // cosmetic; the sort below is what decides.
+    // Intent is vocabulary rather than a stage.
+    // The sort below decides, so `bare_toponym` and `route_pair` sit here cosmetically
+    // and are scored under `locality_only` on purpose (see `intent-rules.ts`).
     { kind: "bare_toponym", score: scoreBareToponym },
     { kind: "route_pair", score: scoreRoutePair },
     { kind: "near_me", score: scoreNearMe },
     { kind: "vague", score: scoreVague },
 ];
 /**
- * Rank a scored list and shape it into a verdict. Shared by the lexicon-free and lexicon-wired paths so the two cannot
- * drift in how they break ties or build `alternatives`.
+ * Rank a scored list into a verdict, shared by the lexicon-free and lexicon-wired paths
+ * so the two cannot drift in how they break ties or build `alternatives`.
  */
 function rank(scored) {
     scored.sort((a, b) => b.confidence - a.confidence);
@@ -48,17 +44,17 @@ function rank(scored) {
     };
 }
 /**
- * Every kind whose verdict carries `intentMarkers`. Checked before the marker builder runs so the hot path — a
- * structured address, where none of these fire — pays one set membership test per kind and nothing else.
+ * Every kind whose verdict includes `intentMarkers`, checked before the marker builder
+ * so the hot path pays one set membership test per kind.
  */
-const MARKER_BEARING_KINDS = new Set(["route_pair", "near_me", "poi_category"]);
+const MARKER_KINDS = new Set(["route_pair", "near_me", "poi_category"]);
 /**
- * Attach markers to a verdict, or return it untouched. Separate from {@link rank} because the lexicon-wired path needs
- * to merge `poi_query`/`poi_category` in first.
+ * Attach markers to a verdict or return it untouched, separate from {@link rank}
+ * because the lexicon-wired path merges `poi_query`/`poi_category` in first.
  */
 function withIntentMarkers(verdict, input, poiLexicon, locale) {
     const kinds = [{ kind: verdict.kind, confidence: verdict.confidence }, ...verdict.alternatives];
-    if (!kinds.some((k) => MARKER_BEARING_KINDS.has(k.kind)))
+    if (!kinds.some((k) => MARKER_KINDS.has(k.kind)))
         return verdict;
     const intentMarkers = deriveIntentMarkers(kinds, { input, poiLexicon, locale });
     if (!intentMarkers.length)
@@ -66,24 +62,24 @@ function withIntentMarkers(verdict, input, poiLexicon, locale) {
     return { ...verdict, intentMarkers };
 }
 /**
- * Classify the query shape into a `QueryKind`. Synchronous + pure — produces the same result for the same `(input,
- * shape)` pair.
+ * Classify the query shape into a `QueryKind`, synchronously and purely,
+ * producing the same result for the same `(input, shape)` pair.
  */
 export function classifyKindSync(input, shape) {
     const scored = SCORERS.map((s) => ({ kind: s.kind, confidence: s.score(input, shape) })).filter((s) => s.confidence > 0);
     return withIntentMarkers(rank(scored), input);
 }
 /**
- * Async variant matching the runtime-pipeline's `classifyKind` contract.
- *
- * The locale parameter is accepted for future locale-aware rules (Japanese honorifics, etc.) but not currently used.
+ * Async variant matching the runtime pipeline's `classifyKind` interface;
+ * `_locale` is accepted for future locale-aware rules but currently unused.
  */
 export async function classifyKind(input, shape, _locale) {
     return classifyKindSync(input, shape);
 }
 /**
- * Build a kind classifier. Without opts this is exactly the default {@link classifyKind}; with a `poiLexicon` it
- * additionally scores `poi_query` + `poi_category` (ROAD_TO_V9 §4.4) and merges them into the ranked result.
+ * Build a kind classifier that is exactly {@link classifyKind} without options,
+ * or that additionally scores `poi_query` + `poi_category` (ROAD_TO_V9 §4.4)
+ * and merges them into the ranked result when given a `poiLexicon`.
  */
 export function createKindClassifier(opts = {}) {
     const { poiLexicon } = opts;
@@ -96,9 +92,10 @@ export function createKindClassifier(opts = {}) {
         const categoryConfidence = createScorePOICategory(poiLexicon, localeTag)(input, shape);
         if (poiConfidence <= 0 && categoryConfidence <= 0)
             return base;
-        // Re-rank over the union rather than special-casing "did POI beat the base?". The base verdict's own
-        // alternatives are preserved, which is what keeps `bare_toponym` / `route_pair` visible to the marker builder
-        // even when a POI kind takes the top slot.
+        // Re-ranking over the union rather than special-casing whether POI beat the
+        // base preserves the base's own alternatives.
+        // Those keep `bare_toponym`/`route_pair` visible to the marker builder even
+        // when a POI kind takes the top slot.
         const merged = [
             { kind: base.kind, confidence: base.confidence },
             ...base.alternatives,

package/out/classify.js.map

@@ -1 +1 @@
-{"version":3,"file":"classify.js","sourceRoot":"","sources":["../lib/classify.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"classify.js","sourceRoot":"","sources":["../lib/classify.ts"],"names":[],"mappings":"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"}

package/out/index.d.ts

@@ -3,14 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   `@mailwoman/kind-classifier` — Stage 2.5 of the runtime pipeline.
- *
- *   Categorize inputs into one of eight `QueryKind`s by composing rule-based scorers over the
- *   QueryShape sub-system's output. Pure functions, no ML, no place-name dictionaries. Returns
- *   possibilities (alternatives) alongside the top pick so the coordinator can fall back when the
- *   winning kind isn't actionable.
- *
- *   See `docs/engineering/reference/STAGES.md` § Stage 2.5 for the contract.
+ *   Stage 2.5 classifier: compose rule-based scorers over QueryShape and return a top kind with alternatives.
  */
 export { classifyKind, classifyKindSync, createKindClassifier } from "#classify";
 export type { KindClassifierOpts } from "#classify";

package/out/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAChF,YAAY,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AACrD,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAC1D,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAC5F,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,MAAM,CAAA;AACxD,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,MAAM,CAAA;AAE9G,OAAO,EACN,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,iBAAiB,EACjB,sBAAsB,EACtB,UAAU,EACV,kBAAkB,GAClB,MAAM,QAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAChF,YAAY,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AACrD,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAC1D,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAC5F,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,MAAM,CAAA;AACxD,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,MAAM,CAAA;AAE9G,OAAO,EACN,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,iBAAiB,EACjB,sBAAsB,EACtB,UAAU,EACV,kBAAkB,GAClB,MAAM,QAAQ,CAAA"}