fix: locale-pack follow-ups — LOCALE_NOT_LOADED enum, size budgets, detection polish

Registers LOCALE_NOT_LOADED in the schema enums (+ regenerated artifacts),
recalibrates the size budgets for the locale entries and ./complete, and
tightens locale detection/profile resolution so the full check passes.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: Aymericr

apps/site/public/schema/dictionary.md

@@ -41,7 +41,7 @@ The compact wire JSON `JSON.stringify(lingo(...))` produces. Generated from
 
 `error`, `warning`, `info`
 
-## Issue codes (32)
+## Issue codes (33)
 
 | code | meaning |
 |---|---|
@@ -59,6 +59,7 @@ The compact wire JSON `JSON.stringify(lingo(...))` produces. Generated from
 | `CONVERSION_NOT_ALLOWED` | A conversion was not allowed here. |
 | `NUMBER_FORMAT` | The number could not be parsed. |
 | `NONFINITE` | The value is not finite. |
+| `LOCALE_NOT_LOADED` | The requested locale pack was not loaded. |
 | `RANGE_MIN` | Value is below the allowed minimum. |
 | `RANGE_MAX` | Value is above the allowed maximum. |
 | `RANGE_OPEN_BOUND_NOT_ALLOWED` | An open-ended range bound was not allowed. |

apps/site/public/schema/lingo.openapi.json

@@ -78,6 +78,7 @@
               "CONVERSION_NOT_ALLOWED",
               "NUMBER_FORMAT",
               "NONFINITE",
+              "LOCALE_NOT_LOADED",
               "RANGE_MIN",
               "RANGE_MAX",
               "RANGE_OPEN_BOUND_NOT_ALLOWED",

apps/site/public/schema/lingo.schema.json

@@ -74,6 +74,7 @@
             "CONVERSION_NOT_ALLOWED",
             "NUMBER_FORMAT",
             "NONFINITE",
+            "LOCALE_NOT_LOADED",
             "RANGE_MIN",
             "RANGE_MAX",
             "RANGE_OPEN_BOUND_NOT_ALLOWED",

packages/lingo/scripts/size.mjs

@@ -129,10 +129,15 @@ function check(label, size, budget) {
 // built-in hooks for tree-shakeable es/fr/pt/zh/ja/en-gb packs. English-only
 // parsing uses a prebuilt singleton, but the shared parser still carries the
 // public `createLingo({ locales })` / `locale` option machinery.
+// 35.8 (was 35.7): D63 — locale correctness hardening: English wins inherited
+// overlay ties, explicit unloaded locales return LOCALE_NOT_LOADED, and zh/ja
+// pack-owned CJK aliases/fuzzy vocab install through a tiny registry hook.
 const full = await bundleStdin(`export * from './src/index.ts'`)
-check('lingo (full)', full, 35_700)
+check('lingo (full)', full, 35_800)
 
 if (has('src/locales/es.ts')) {
+  const enLocale = await bundleStdin(`export * from './src/locales/en.ts'`)
+  check('./locales/en (standalone data)', enLocale, 1800)
   const esLocale = await bundleStdin(`export * from './src/locales/es.ts'`)
   check('./locales/es (standalone data)', esLocale, 1150)
   const frLocale = await bundleStdin(`export * from './src/locales/fr.ts'`)
@@ -318,7 +323,9 @@ if (has('src/complete/index.ts')) {
   // D60/D61 — ./complete: ranked autocomplete fan-out (unit ambiguity, prefix,
   // range-tail implied units, curated suggest-units table). Marginal is the
   // orchestrator + aliasCompletions index walk; not re-exported from `.`.
-  check('./complete (marginal over full)', withComplete - full, 2250)
+  // 2.4 (was 2.25): D63 gzip interaction after the full-entry locale
+  // correctness hardening; ./complete code itself did not grow.
+  check('./complete (marginal over full)', withComplete - full, 2400)
 }
 
 if (has('src/schema/index.ts')) {

packages/lingo/src/complete/suggest-units.ts

@@ -170,36 +170,91 @@ export function inferKindFromRangeLeft(
   return
 }
 
-export function extractRangeBounds(
-  tokens: Token[],
-  sepIndex: number,
-): { left: string; right: string } | null {
-  let left: string | null = null
-  let right: string | null = null
-  for (let i = 0; i < sepIndex; i++) {
+function isNumericRunToken(t: Token): boolean {
+  return (
+    t.type === 'digits' ||
+    t.type === 'vulgar' ||
+    (t.type === 'sym' && (t.text === '.' || t.text === ','))
+  )
+}
+
+/** Full text of the numeric literal ending just before `sepIndex`, or null. */
+function leftBoundText(tokens: Token[], text: string, sepIndex: number): string | null {
+  let anchor = -1
+  for (let i = sepIndex - 1; i >= 0; i--) {
     const t = tokens[i]!
     if (t.type === 'digits' || t.type === 'vulgar') {
-      left = t.text
+      anchor = i
+      break
     }
   }
+  if (anchor < 0) {
+    return null
+  }
+  let edge = anchor
+  while (edge > 0 && !tokens[edge]!.spaceBefore && isNumericRunToken(tokens[edge - 1]!)) {
+    edge--
+  }
+  // A word glued to the front ("1h30") is a compound, not a clean number.
+  if (edge > 0 && !tokens[edge]!.spaceBefore && tokens[edge - 1]!.type === 'word') {
+    return null
+  }
+  return text.slice(tokens[edge]!.start, tokens[anchor]!.end)
+}
+
+/** Full text of the numeric literal starting just after `sepIndex`, or null. */
+function rightBoundText(tokens: Token[], text: string, sepIndex: number): string | null {
+  let anchor = -1
   for (let i = sepIndex + 1; i < tokens.length; i++) {
     const t = tokens[i]!
     if (t.type === 'digits' || t.type === 'vulgar') {
-      right = t.text
+      anchor = i
       break
     }
   }
-  return left && right ? { left, right } : null
+  if (anchor < 0) {
+    return null
+  }
+  let lo = anchor
+  while (lo > sepIndex + 1 && !tokens[lo]!.spaceBefore && isNumericRunToken(tokens[lo - 1]!)) {
+    lo--
+  }
+  let hi = anchor
+  while (
+    hi + 1 < tokens.length &&
+    !tokens[hi + 1]!.spaceBefore &&
+    isNumericRunToken(tokens[hi + 1]!)
+  ) {
+    hi++
+  }
+  // A word glued to either end ("1h30") is a compound, not a clean number.
+  if (lo > sepIndex + 1 && !tokens[lo]!.spaceBefore && tokens[lo - 1]!.type === 'word') {
+    return null
+  }
+  if (hi + 1 < tokens.length && !tokens[hi + 1]!.spaceBefore && tokens[hi + 1]!.type === 'word') {
+    return null
+  }
+  return text.slice(tokens[lo]!.start, tokens[hi]!.end)
+}
+
+export function extractRangeBounds(
+  tokens: Token[],
+  text: string,
+  sepIndex: number,
+): { left: string; right: string } | null {
+  const left = leftBoundText(tokens, text, sepIndex)
+  const right = rightBoundText(tokens, text, sepIndex)
+  return left !== null && right !== null ? { left, right } : null
 }
 
-/** Canonical hyphen-range rewrite when both bounds are known. */
+/** Canonical hyphen-range rewrite when both bounds are clean numeric literals. */
 export function rangeRewriteWithUnit(
   tokens: Token[],
   text: string,
   tail: RangeTail,
   alias: string,
 ): string {
-  const bounds = extractRangeBounds(tokens, tail.sepIndex)
+  const bounds = extractRangeBounds(tokens, text, tail.sepIndex)
   if (bounds) {
     return `${bounds.left}-${bounds.right} ${alias}`
   }

packages/lingo/src/core/registry.ts

@@ -182,9 +182,8 @@ export class Registry {
   registerUnitAliases(kind: Kind, unitRef: string, aliases: readonly string[]): void {
     const unit = this.unitByRef(kind, unitRef)
     if (!unit) {
-      throw new Error(`lingo: unknown unit "${unitRef}" in kind "${kind}"`)
+      return
     }
-    unit.aliases = [...new Set([...(unit.aliases ?? []), ...aliases])]
     for (const alias of aliases) {
       this.insert(this.ci, alias.toLowerCase(), false, kind, unit)
     }

packages/lingo/src/date/parse.ts

@@ -1,6 +1,6 @@
 import { makeIssue } from '../core/errors'
 import type { IssueCode, IssueInputData, LingoIssue, Messages, Severity, Span } from '../core/types'
-import { isLocaleLoaded, resolveLanguageProfile } from '../locale/profile'
+import { resolveLanguageProfile } from '../locale/profile'
 import type { LocalePack } from '../locale/types'
 import { normalizeInput, toSourceSpan } from '../parse/normalize'
 import type { SerializedResult } from '../parse/serialize'
@@ -155,30 +155,18 @@ export function parseDate(text: string, opts?: DateOptions): DateResult | DateFa
 function parseDateImpl(text: string, opts?: DateOptions): DateResult | DateFail<DateResult> {
   const now = opts?.now === undefined ? anchorNow() : new Date(opts.now.getTime())
   const n = normalizeInput(text)
-  const localeNotLoaded =
-    opts?.locale !== undefined && !isLocaleLoaded(opts.localePacks, opts.locale)
-      ? makeIssue(
-          'LOCALE_NOT_LOADED',
-          { locale: opts.locale },
-          toSourceSpan(n, 0, n.text.length),
-          opts.messages,
-        )
-      : undefined
   const p: P = {
     src: text,
     n,
     text: n.text,
     tokens: tokenize(n),
     now,
     opts: opts ?? {},
-    profile: resolveLanguageProfile(opts?.localePacks, localeNotLoaded ? 'en' : opts?.locale),
+    profile: resolveLanguageProfile(opts?.localePacks, opts?.locale),
     weekStart: normalizeWeekStart(opts?.weekStart),
     forwardDates: opts?.forwardDates ?? true,
     escalate: dateEscalate(opts),
   }
-  if (localeNotLoaded) {
-    return { ok: false, text: p.src, issues: [localeNotLoaded] }
-  }
   const { start, end } = trimRange(n.text, 0, n.text.length)
   if (start === end) {
     return fail(p, 'NO_VALUE', { example: '"tomorrow"' }, start, end)
@@ -394,30 +382,18 @@ export function parseDateRange(text: string, opts?: DateOptions): DateRange | Da
 function parseDateRangeImpl(text: string, opts?: DateOptions): DateRange | DateRangeFail {
   const now = opts?.now === undefined ? anchorNow() : new Date(opts.now.getTime())
   const n = normalizeInput(text)
-  const localeNotLoaded =
-    opts?.locale !== undefined && !isLocaleLoaded(opts.localePacks, opts.locale)
-      ? makeIssue(
-          'LOCALE_NOT_LOADED',
-          { locale: opts.locale },
-          toSourceSpan(n, 0, n.text.length),
-          opts.messages,
-        )
-      : undefined
   const p: P = {
     src: text,
     n,
     text: n.text,
     tokens: tokenize(n),
     now,
     opts: opts ?? {},
-    profile: resolveLanguageProfile(opts?.localePacks, localeNotLoaded ? 'en' : opts?.locale),
+    profile: resolveLanguageProfile(opts?.localePacks, opts?.locale),
     weekStart: normalizeWeekStart(opts?.weekStart),
     forwardDates: opts?.forwardDates ?? true,
     escalate: dateEscalate(opts),
   }
-  if (localeNotLoaded) {
-    return { ok: false, type: 'date-range-failure', text, issues: [localeNotLoaded] }
-  }
   let source = n.text.trim()
   const issues: LingoIssue[] = []
   // Point the span at the trimmed content, not the padded input.

packages/lingo/src/factory.ts

@@ -343,9 +343,7 @@ function installLocalePacks(
 ): void {
   for (const pack of packs ?? []) {
     for (const { kind, unit, aliases } of pack.unitAliases ?? []) {
-      if (reg.unitByRef(kind, unit)) {
-        reg.registerUnitAliases(kind, unit, aliases)
-      }
+      reg.registerUnitAliases(kind, unit, aliases)
     }
     if (!includeFuzzy) {
       continue

packages/lingo/src/locale/detect.ts

@@ -13,21 +13,21 @@ export function detectLanguageProfile(
 }
 
 export function detectLocale(packs: readonly LocalePack[], input: string): string | undefined {
-  let best: { index: number; locale: string; score: number } | undefined
-  const candidates: LanguageProfile[] = [
-    englishLanguageProfile,
-    ...packs
-      .filter((pack) => normalizeLocale(pack.locale) !== 'en')
-      .map((pack) => resolveLanguageProfile(packs, pack.locale)),
-  ]
-  for (let i = 0; i < candidates.length; i++) {
-    const profile = candidates[i]!
+  let best: { locale: string; score: number } = {
+    locale: 'en',
+    score: scoreProfile(englishLanguageProfile, input),
+  }
+  for (let i = 0; i < packs.length; i++) {
+    if (normalizeLocale(packs[i]!.locale) === 'en') {
+      continue
+    }
+    const profile = resolveLanguageProfile(packs, packs[i]!.locale)
     const score = scoreProfile(profile, input)
-    if (!best || score > best.score || (score === best.score && i < best.index)) {
-      best = { index: i, locale: profile.locale, score }
+    if (score > best.score) {
+      best = { locale: profile.locale, score }
     }
   }
-  return best && best.score > 0 ? best.locale : undefined
+  return best.score > 0 ? best.locale : undefined
 }
 
 export function scoreProfile(profile: LanguageProfile, input: string): number {

packages/lingo/src/locale/profile.ts

@@ -31,7 +31,10 @@ export function hasNonEnglishLocalePacks(packs?: readonly LocalePack[]): boolean
 }
 
 export function isLocaleLoaded(packs: readonly LocalePack[] | undefined, locale: string): boolean {
-  return Boolean(findPack(uniquePacks([...DEFAULT_LOCALE_PACKS, ...(packs ?? [])]), locale))
+  const target = normalizeLocale(locale)
+  return (
+    matchesLocale(enCore, target) || (packs?.some((pack) => matchesLocale(pack, target)) ?? false)
+  )
 }
 
 function buildProfile(