l10n: put the translation files through the wringer — all 36 locales at full parity - #2634
Draft
SudoThijn wants to merge 86 commits into
Draft
l10n: put the translation files through the wringer — all 36 locales at full parity#2634SudoThijn wants to merge 86 commits into
SudoThijn wants to merge 86 commits into
Conversation
Rewrites every l10n/*.js with keys in case-insensitive alphabetical order so that subsequent translation diffs are small and reviewable. Previously the bundles carried historical insertion order, which meant any tool that rewrote a file produced a whole-file diff and buried the actual changes. Sorting is case-insensitive with a code-unit tie-break, so it is deterministic and does not depend on the Node/ICU localeCompare implementation. Purely mechanical: values were taken from HEAD and verified unchanged. Verified across all 37 files / 54113 keys: zero value changes, zero keyset changes, all files valid JS, OC.L10N.register executes with the expected key count and plural-forms string.
Ten Dutch entries were still defective after the main Dutch pass: Half-translated machine output, Dutch words in English word order: "Weet u zeker dat u wilt verwijderen the geselecteerd audittrails?" "No bestands have been extracted yet" "Kon niet update schema properties" "Select default organisatie" and two "Use filters to narrow down ..." strings left almost fully English Formal address, which the rest of the bundle and Nextcloud core both avoid: "Dank u!" -> "Bedankt!", "uw" -> "je", "Weet u zeker" -> "Weet je zeker" These slipped through because the previous check had no formal-address test at all, and its English-marker list excluded so many words that collide with Dutch that badly-mixed strings scored as clean. Note the embeddings warning exists twice in the bundle, once with a literal \n escape and once with a real newline; only the escaped copy was broken. Verified: 0 keys lost, 0 added, exactly 10 values changed, 0 formal-address entries remaining, 0 plural-arity errors.
Brings l10n/de.js from 950 to full coverage of every string the frontend
requests via t()/n(). No entry has a value equal to its key.
harvested 63 existing Transifex output for the identical source
string, from sibling Conduction apps and the
Nextcloud server tree
hand-translated 970 written for this app
formal -> informal 98 see below
placeholders 109 entries whose value equalled their key
identity keys 65 removed, see below
Register: informal du/dein throughout. Nextcloud ships the formal German
variant as a separate de_DE locale, and openregister has no de_DE, so plain
de.js is the informal bundle. Verified against the server tree:
core/l10n/de.js is 58 informal vs 1 formal, settings 108 vs 4. 98 pre-existing
entries used "Sie"/"Ihr" and were rewritten ("Verwalten Sie Ihre Register" ->
"Verwalte deine Register").
Identity strings are ABSENT rather than stored as value===key. For source
strings that are genuinely the same word in German ("Code", "Status", "Port",
"Maximum", "Repository") or must not be translated at all ("sk-...",
"https://example.com/webhook") OC.L10N falls back to the English source and
renders identical text, but the entry is no longer indistinguishable from an
untranslated placeholder. Tracked in de-identity.json.
Terminology: the source embeds Dutch legal vocabulary, which is mapped to
German equivalents rather than passed through -- "Inzage (Art 15)" ->
"Auskunft (Art. 15)", "Art 17 vergetelheid" -> "Recht auf Vergessenwerden",
"Art 20 portabiliteit" -> "Datenübertragbarkeit", "Bewaartermijn" ->
"Aufbewahrungsfrist", "verwerkingsactiviteit" -> "Verarbeitungstätigkeit",
"verantwoordingsdocument" -> "Rechenschaftsdokument", GDPR/AVG -> DSGVO.
Three harvested values were rejected as wrong for this app's context:
"Open" -> "Öffnen" (a button, not the adjective "Offen"), "Right" -> "Recht"
(an RBAC permission, not the direction "Rechts"), "Subject" ->
"Betroffene Person" (a GDPR data subject, not an email "Betreff").
Known source-side limitation: the "object{plural}" family interpolates a
literal "s"/"" for pluralisation, which cannot work in German. Those render as
"Objekt(e)"; "schema{plural}" keeps the placeholder because German does
pluralise Schema with -s.
Verified: 1996/1996 frontend keys translated, 0 absent, 0 value===key anywhere
in the bundle, 0 plural-arity errors, 0 unreviewed formal address, all 5 plural
keys carry 2-form arrays, file is valid JS and OC.L10N.register executes with
2324 keys. No pre-existing translation was lost: the only 33 baseline keys
removed were deliberate identity strings that had been value===key.
Brings l10n/fr.js from 951 to full coverage of every string the frontend
requests via t()/n(). No entry has a value equal to its key.
harvested 61 existing Transifex output for the identical source
string, from sibling apps and the Nextcloud server tree
hand-translated 920 written for this app
placeholders 27 entries whose value equalled their key
identity keys 86 removed, see below
Register: FORMAL (vous/votre), which is what Nextcloud core actually uses for
French. This differs from the informal de/nl bundles and was measured, not
assumed: across server/{core,lib,apps/*}/l10n, fr is 39 informal vs 412 formal
(core alone 76 vs 9, settings 171 vs 16), and core ships no separate formal
French variant. The rule is "match Nextcloud core", and for French that means
vous.
Identity strings are ABSENT rather than stored as value===key, so the runtime
falls back to the English source and renders identical text without the entry
being indistinguishable from an untranslated placeholder. French shares a great
deal of vocabulary with English here ("Action", "Configuration", "Description",
"Format", "Total", "Type", "Version", "Notifications", "Expiration", "Notes",
"Score", "Public"), so the identity list is larger than German's. Tracked in
fr-identity.json.
Typography follows French convention: a space before ':' '?' '!' and guillemets
« » for quoted UI labels, as Nextcloud French does.
Terminology: Dutch legal vocabulary in the source is mapped to French GDPR
terms -- "Inzage (Art 15)" -> "Accès (art. 15)", "Art 17 vergetelheid" ->
"droit à l'oubli", "Art 20 portabiliteit" -> "portabilité", "Bewaartermijn" ->
"Durée de conservation", "verwerkingsactiviteit" -> "activité de traitement",
"verantwoordingsdocument" -> "document de responsabilité", AVG/GDPR -> RGPD.
Five harvested values were rejected as wrong for this app's context:
"Open" -> "Ouvrir" (button, not the adjective "Ouvert"), "View" -> "Afficher"
(action verb, not the noun "Affichage"), "Right" -> "Droit" (RBAC permission,
not the direction "Droite"), "Subject" -> "Personne concernée" (GDPR data
subject, not email "Objet"), "Link" -> "Associer" (dialog button verb, not the
noun "Lien").
Note French plural-forms is "nplurals=2; plural=(n > 1)", unlike German's
"(n != 1)"; all 5 plural keys carry correctly ordered 2-form arrays.
Verified: 1996/1996 frontend keys translated, 0 absent, 0 value===key anywhere
in the bundle, 0 plural-arity errors, 0 unreviewed wrong-register entries, file
is valid JS and OC.L10N.register executes with 2315 keys. No pre-existing
translation was lost: all 49 baseline keys removed were deliberate identity
strings that had been value===key.
Removes entries that are BOTH unreachable and untranslated:
* no t()/n() call requests the key — neither a literal call nor any of the
enumerated dynamic ones (see below), and
* the value equals the key, i.e. it was never translated.
This cannot change what any user sees. An entry whose value equals its key
already renders the English source string; once removed, OC.L10N falls back to
the English source and renders the same string. Verified mechanically across all
37 files: 904 keys removed, 0 of them holding anything other than value===key,
and 0 existing values altered.
Unreachable keys that DO carry a real translation were deliberately left alone.
They are harmless, and deleting them would risk discarding real translation work
if the reachability analysis were ever incomplete.
Most of these are residue from two known events. Commit 03cda6c ("fix(i18n):
unwrap numeric/URL placeholders from t() per PR #1273 review") correctly stopped
wrapping numeric and infrastructure-URL placeholders in t(), but never removed
the keys it orphaned -- hence "3", "30", "http://localhost:11434" and
"https://api.fireworks.ai/inference/v1" in every bundle. Separately, the SOLR /
Zookeeper settings UI was removed from src/ without cleaning its strings, so
keys like "Zookeeper Hosts" and "SOLR Connection Settings" survive with no call
site. Confirmed absent from src/ before removal.
en.js is excluded: it is the English source bundle, where value===key is correct
by definition rather than a placeholder.
All 37 files remain valid JS.
…traction missed
Some strings reach t() as a variable rather than a literal:
t('openregister', action) PermissionMatrix.vue:41, over
actions: ['read','create','update','delete','manage']
t('openregister', step.status) ApprovalStepList.vue:17, over the approval
statuses used by lib/Controller/ApprovalController.php
t('openregister', preset.label) DashboardIndex.vue:91/120/360, over the date
presets declared at :212-216
None of these keys can be found by scanning for literal t() arguments, so all 15
were absent from every bundle. The Permission Matrix column headers, the
approval-status badges and the dashboard date-range presets were therefore
rendering in English even in locales reported as fully translated. The key list
now lives in dynamic-keys.json with its provenance, and feeds the same
absent/placeholder/register checks as every other key.
Two dynamic sites remain un-enumerable and are documented as such: ApprovalStepList
step.role (schema-configured, arbitrary) and MainMenu.vue:76 translate(key) (app
manifest labels). A third, RegisterSchemaCard.vue:714, wraps a runtime-built
template string in t() and so can never match a catalogue key — that is a source
bug rather than a missing translation.
Also in this commit, for nl only:
* "Driver" -> "Stuurprogramma", "Url" -> "URL", "object{plural}" -> "object(en)",
"log{plural}" -> "logboek(en)", and both real-newline variants of the
PERMANENT DELETION WARNING, which had only been done for the \n-escaped copies
* 29 identity strings ("Code", "Status", "Type", "Dashboard", "sk-...") converted
from value===key to absent, matching the treatment already applied to de and fr
* nl-identity.json reconstructed (72 entries) so the check is reproducible
Verified: nl, de and fr each report 2011/2011 keys translated with 0 absent,
0 value===key, 0 wrong-register and 0 plural-arity errors.
Brings es.js from 972 to 2011 reachable keys: 983 new translations,
16 placeholder entries replaced with real Spanish, and 17 legitimate
identity strings dropped so they fall back to the English source
instead of masquerading as translations.
Also fixes 106 PRE-EXISTING entries that the earlier register check
could not see. Spanish is pronoun-dropping, so formality lives in the
verb, not in a pronoun: "Seleccione un registro" is formal address with
no "usted" anywhere, and a check for the pronoun alone reported the
bundle clean. Widening the check to the usted imperative (3rd-sg
subjunctive: -ar -> -e, -er/-ir -> -a) plus the possessive su/sus
surfaced 107 formal entries, 105 of which were converted to the tú
forms Nextcloud core uses for Spanish. The remaining one was a
terminology split ("Rastro de auditoría" against nine occurrences of
"registro de auditoría").
The verb list was harvested from the sentence-initial and
post-punctuation words actually present in es.js rather than guessed —
"Gestione" and "Habilite" were both missing from the guessed list.
su/sus is both the formal "your" and the third-person "his/her/its/
their", so it is gated on the English source containing "your";
where the source says "its"/"their", su/sus is simply correct. Ten
positive/negative controls cover the gate. Only five strings that say
both "your" and "their" still need suppressing by hand.
Harvest sources are now ranked core-first. Previously the walk order
let sibling Conduction apps shadow server/, so generic UI strings were
taken from apps whose own Spanish is not authoritative. Eleven of the
67 harvested values were still wrong for this app's context and were
rewritten: Open/View/Link are verb buttons here (Abrir/Ver/Vincular,
not Abierto/Vista/Enlace), Right is a permission (Derecho, not the
direction Derecha), Subject is the GDPR data subject (Interesado, not
the email Asunto), and Languages are human languages (Idiomas, not
Lenguajes).
Unlike German and Dutch, Spanish pluralises with -s exactly as English
does, so the object{plural}/register{plural} family interpolates
correctly here and is translated with the placeholder intact.
Verified: 2011/2011 reachable keys, 0 absent, 0 value===key, 0 hybrid,
0 wrong register, 0 plural-arity errors, valid JS, and OC.L10N.register
loads all 2355 entries. Backend l10n/es.json is untouched.
Brings it.js from 969 to 2011 reachable keys: 983 new translations, 17
placeholder entries replaced with real Italian, and 19 legitimate
identity strings dropped so they fall back to the English source
instead of masquerading as translations.
No pre-existing entry needed rewriting — unlike Spanish, the Italian
already in the bundle was consistently informal (Seleziona, Gestisci,
Crea). That is a verified result rather than an assumption: the register
check for Italian was as blind as the Spanish one, matching only
(Lei|Vi preghiamo), which finds almost nothing in a pronoun-dropping
language. It now covers the usted-equivalent imperative, which in
Italian is the MIRROR of Spanish: -are -> -i (selezioni), -ere/-ire -> -a
(scelga, inserisca). That collides head-on with the INFORMAL -ere/-ire
imperative, which also ends in -i (scegli, inserisci), so the ending
alone proves nothing and the verb list is explicit.
Filtri, Ordini, Usi, Controlli, Termini, Continui and Faccia are left
out on purpose: each is an ordinary Italian noun or adjective and would
bury real hits in noise. Infinitive-as-instruction ("Eliminare",
"Utilizzare") is standard register-neutral Italian UI and is not
flagged. 16 positive/negative controls cover the pattern, including one
that caught a genuine inversion in my first draft: "Premi" is the
INFORMAL imperative of premere and had been listed as formal.
Six of the 70 harvested values were wrong for this app's context.
Subject was the worst: pipelinq's "Oggetto" is the email subject AND
this bundle's own word for Object, so a GDPR data subject column would
have read "Object" — it is "Interessato". Open/Link are verb buttons
here (Apri/Collega, not Aperto/Collegamento), Right is a permission
(Diritto, not the direction Destra), Other labels a group (Altri), and
Mappings is properly "Mappature". "Test" was also reclassified: it is a
webhook action button, so Italian wants the verb "Prova", not the noun
loanword.
Italian pluralises by vowel change, not with -s, so the
object{plural}/register{plural} family CANNOT use the literal "s" the
source interpolates — it would render "oggettos". Those are written with
an explicit both-forms notation (oggetto/i, registro/i, schema/i), and
file{plural}/log{plural} simply drop the placeholder because both nouns
are invariant in Italian.
"{count} email" is the one entry deliberately written as value===key:
"email" is invariant, so both plural forms equal the English source, and
leaving the key ABSENT is not equivalent — OC.L10N would fall back to
the English plural rule and render "{count} emails". apply.js gained a
narrow --allow-identity opt-in for exactly this case; --force still does
not lift the value===key ban.
Verified: 2011/2011 reachable keys, 0 absent, 0 hybrid, 0 wrong
register, 0 plural-arity errors, valid JS, OC.L10N.register loads all
2353 entries, and the only value===key entry is the documented
invariant plural. No pre-existing translation was altered. Backend
l10n/it.json is untouched.
Brings pt.js from 973 to 2011 reachable keys: 984 new translations, 17
placeholder entries replaced with real Portuguese, and 15 legitimate
identity strings dropped so they fall back to the English source
instead of masquerading as translations.
PORTUGUESE INVERTS THE SPANISH RULE, and getting that backwards would
have wrecked the whole locale. In Spanish, "Seleccione" / "su" is
deferential usted and had to be replaced with tú forms. In Portuguese
the same 3rd-person morphology ("Selecione" / "seu") is the NEUTRAL você
register that Portuguese software UI uses, and the 2nd-person tu forms
are the ones that read wrong. Measured rather than assumed, across
server/{core,lib,apps/*}:
pt_BR tu 0 : você 438
pt_PT tu 4 : você 128
Both variants converge on você, so the single generic "pt" bundle this
app ships is correct for both. The register check for pt was therefore
written to flag the TU forms, with a comment saying so, because the
obvious next move for anyone reading the Spanish entry would be to
"fix" it by analogy and break 2000 strings. 10 positive/negative
controls pin the direction down.
The bundle is EUROPEAN Portuguese and the new strings follow it:
ficheiro, registo, eliminar, guardar, utilizador, aplicação,
definições. That was measured too (306 pt_PT-style terms against 11
apparent pt_BR ones, and all 11 turned out to be correct anyway —
"padrão" translates Pattern, not "default", and "configurações"
renders configurations as distinct from settings/"definições").
Existing style is also preserved: infinitive for controls (Selecionar,
Criar, Eliminar) and você imperative for prose instructions (Selecione,
Configure, Introduza).
Only one pre-existing entry was changed: "Trilho de auditoria" against
nine occurrences of "registo de auditoria".
Three of the 31 harvested values were wrong for this app's context —
Right is a permission (Direito, not the direction Direita), Link is a
confirm button (Associar, not the noun Ligação), and Edit Endpoint kept
the loanword to match the bundle's existing "Adicionar Endpoint" rather
than openconnector's "ponto final". None of the harvest was
authoritative here: core ships pt_BR and pt_PT but no bare pt, so every
candidate came from a sibling Conduction app and each was reviewed.
Like Spanish and unlike Italian, Portuguese pluralises with -s, so the
object{plural}/register{plural} family works with the literal "s" the
source interpolates and is translated with the placeholder intact.
Verified: 2011/2011 reachable keys, 0 absent, 0 value===key, 0 hybrid,
0 wrong register, 0 plural-arity errors, valid JS, and OC.L10N.register
loads all 2357 entries. Backend l10n/pt.json is untouched.
Brings sv.js from 958 to 2011 reachable keys: 981 new translations, 15
placeholder entries replaced with real Swedish, and 23 legitimate
identity strings dropped so they fall back to the English source
instead of masquerading as translations. No pre-existing translation
was altered.
Swedish shares far more of this app's vocabulary outright than the
Romance locales do, which cut both ways. The identity list is nearly
twice as long (register, schema, status, organisation, person, port,
version, format, maximum, minimum are all Swedish words with the same
spelling) and the hybrid detector was firing on nine perfectly good
Swedish strings purely because they contained "register" and "schema".
Those words are now declared as collisions for sv, the same treatment
de and nl already needed, so a hybrid hit means something again.
Register/Schema are capitalised mid-sentence throughout, which is not
standard Swedish orthography but IS this bundle's established
convention for the domain entities — measured at 54 capitalised
against 2 lowercase before I added anything, so the new strings follow
it rather than splitting the file two ways. Terms with their own
precedent keep it: "slutpunkt" stays lowercase to match the existing
"Lägg till slutpunkt".
Swedish is informal by default (du) — 358 informal against 0 formal in
core — and needed no register conversion.
Four of the 45 harvested values were wrong for this app's context: Open
is a verb button here (Öppna, not the adjective Öppen that circles
supplies), Right is a permission (Rättighet, not the direction Höger),
Link is a confirm button (Länka, not the noun Länk), and Edit Endpoint
was recased to match the bundle. Core's "Webbadress" for URL was
deliberately NOT taken: this bundle uses "URL" consistently (Bas-URL,
Databas-URL, "namn eller URL"), so the standalone label stays identity.
Swedish pluralises by suffix change or not at all, never with -s, so
the {plural} family cannot use the literal "s" the source interpolates.
These are count-labels under a number, so: object{plural} and
register{plural} drop the placeholder entirely (both nouns are
invariant — "5 objekt", "5 register"), while file{plural},
log{plural} and schema{plural} use an explicit both-forms notation
(fil(er), logg(ar), schema(n)).
Verified: 2011/2011 reachable keys, 0 absent, 0 value===key, 0 hybrid,
0 wrong register, 0 plural-arity errors, valid JS, and OC.L10N.register
loads all 2347 entries with no benign suppressions needed at all.
Backend l10n/sv.json is untouched.
Every string the frontend reaches via t()/n() now has a real Danish
translation. 981 new entries, 15 English placeholders replaced, 23
identity strings dropped so the runtime falls back to the source.
No pre-existing translation was altered except one grammar fix (below).
Register: informal (du/din/dit/dine), verified against Nextcloud core.
The old detector for Danish was /(De|Deres)/ and reported 15 hits in
core. All 15 were false positives: lowercase de/dem/deres are the
ordinary words for they/them/their -- and "de" is also the definite
article -- so they capitalise at sentence start and become
indistinguishable from the formal pronouns. "De genererede billeder" is
"The generated images"; "Deres stier" is "Their paths". Core is
572 informal : 0 genuinely formal.
Rewrote the detector to require a MID-SENTENCE capital, excluding every
position where a capital is explained by orthography rather than
register (string start, after sentence punctuation, after newline or
bullet, after an opening quote). Danish opens quotes with the glyph
English uses to close them, so both directions count as sentence start.
Validated on 16 must-not-fire and 6 must-fire controls, then swept all
4487 Danish strings in core: 0 hits, down from 15. Applied to nb/nn too.
Domain-term capitalisation is the INVERSE of Swedish. Swedish measured
54 capitalised : 2 lowercase and so keeps Register/Schema capitalised
mid-sentence; Danish measures 1 : 15 and follows standard orthography,
so register/skema/organisation/objekt stay lowercase.
Bundle consistency over core, twice:
- imperative of -ere verbs: bundle is Aktivér 13:0, core prefers
Aktiver 21:7. Followed the bundle.
- "endpoint": bundle 5:0, harvest offered core-adjacent "slutpunkt".
Kept endpoint.
Where the bundle already had a mapping it wins outright: Host -> Vært,
so unlike Italian this bundle needed no identity entry for "Host *".
Harvest corrections (3 of 41 candidates were wrong in context):
- "Right" is a permissions-table header (EditOrganisation.vue:288),
not a direction -- Rettighed, not Højre.
- "Assigned collaborative tags" arrived as "Tildelte samarbejds tags";
Danish compounds are one word -> samarbejdstags.
- "Edit Endpoint" -> Rediger endpoint, per the bundle term above.
Single-word keys were resolved at the call site, not from the harvest:
Subject is the GDPR data subject (AvgIndex.vue:384) -> Registreret, not
the email sense; Open/View/Reject/Merge/Reverse/Link are verb buttons;
Score/Step/Survivor read off their table headers.
The {plural} source bug (the caller interpolates a literal "s") cannot
work in Danish, which pluralises by suffixing -er and mutates the stem
of register. Resolved per word: objekt(er), fil(er), log(ge),
skema(er), and register/registre where the stem changes.
48 identity strings stay absent rather than being written as value===key
(acronyms, loanwords Danish shares, and literal input examples such as
HTTP headers and YAML snippets, which would stop being valid hints if
translated). Rationale for each is recorded per key.
Also fixes a pre-existing grammar error: "Objekter bløde slettes" ->
"Objekter blødslettes".
…eys)
Every string the frontend reaches via t()/n() now has a real Norwegian
translation. 984 new entries, 15 English placeholders replaced, 20
identity strings dropped so the runtime falls back to the source. No
pre-existing translation was altered.
Register: informal (du/din/ditt/dine), measured against Nextcloud core
rather than assumed from Danish. The De/Dem/Deres detector corrected in
the previous commit carries over unchanged and pays off immediately:
the old /(De|Deres)/ found 10 hits in Norwegian core, all of them
sentence-initial "The/They"; the mid-sentence-capital version finds 0.
Core is 500 informal : 0 genuinely formal.
Norwegian agrees with Danish on orthography (register/skjema lowercase
mid-sentence, measured 1:15) but disagrees on almost everything else,
which is why each convention was re-measured instead of inherited:
- imperative of -ere verbs: nb is "Aktiver" 13:0, exactly mirroring
da's "Aktivér" 13:0. Same verb, opposite spelling.
- error phrasing: nb bundle uses the ACTIVE "Kunne ikke <infinitive>",
where the Danish bundle preferred a passive construction.
- ellipsis: nb bundle puts a space before it, 49:0 ("Laster inn ...").
Followed for every progress string in this commit.
- cache -> "buffer" (bundle-established: Appbutikk-bufferen,
navnebuffer), not the "hurtiglager" core sometimes uses.
- schema -> "skjema", endpoint -> "endepunkt" (Danish kept "endpoint").
Harvest corrections (7 of 46 candidates were wrong in context, the
highest error rate of any locale so far):
- "Right" is a permissions-table header, not a direction -> Rettighet.
- "Revoke" arrived as core's "Avslå", which means REJECT. Revoking a
token is "Tilbakekall".
- "People" arrived as "Mennesker" (humans in the abstract); it labels
the PERSON entity type in EntitiesTab.vue:102 -> Personer.
- "Link" arrived as the noun "Lenke" but is a confirm button
(LinkObjectDialog.vue:62) -> "Knytt til". Kept the lenke/tilknytning
split so Link and Connection stay distinct concepts, since the app
ships both as separate features.
- "Dashboard not found" -> Instrumentpanel, matching core's own
translation of the Dashboard app name.
- "Unknown widget type" arrived as "modultype"; core's dashboard app
leaves widget untranslated, and "modul" is already used in this
bundle for application modules, so "widgettype" avoids the clash.
- "Assigned collaborative tags" lacked plural agreement -> Tildelte.
Accepted core over instinct once: "Bucket" -> "Bøtte", because core's
files_external is exactly the S3 domain this field belongs to. The
Danish bundle kept "Bucket" only because Danish core offers no entry.
Likewise "Host *" -> "Server *", core's rendering for this same field.
The {plural} source bug needed the same per-word handling as Danish, but
with Norwegian's own forms: objekt(er), fil(er), logg(er), skjema(er),
and register/registre where the stem changes.
42 identity strings stay absent rather than being written as value===key.
"Min ms" is included with a note: "min" also means "my" in Norwegian, but
beside a millisecond unit the Minimum reading is unambiguous.
Every string the frontend reaches via t()/n() now has a real Polish
translation. 987 new entries, 15 English placeholders replaced, 14
identity strings dropped so the runtime falls back to the source. No
pre-existing translation was altered.
FIRST nplurals=3 LOCALE. All six plural keys now carry three forms
matching the declared rule (n==1 / n%10 in 2-4 / rest), verified at
runtime: obiekt / obiekty / obiektów. Every locale before this was
nplurals=2, so this is the first bundle where a two-form array would
have silently mis-rendered the genitive plural.
Register: informal, measured against core (154 informal : 0 formal).
Core's imperative style is 2nd-person singular -- Wybierz, Zapisz,
Kliknij (334 hits) -- with impersonal "Nie można" for errors (172), and
the polite 3rd-person "Proszę wybrać" appears only 19 times. Followed
that: 2sg imperatives, impersonal error phrasing.
The register detector needed rebuilding for a homograph problem that is
worse here than in Scandinavian. Formal address is Pan/Pani/Państwo, but
lowercase "państwo" is the ordinary noun for STATE / COUNTRY -- a word
this app plausibly uses, since it manages government registers -- and it
capitalises at sentence start like any other noun. Państwo therefore
counts only MID sentence; Pan/Pani match anywhere, since as address they
stay capitalised. 15 controls (10 must-not-fire, 5 must-fire) pass, and
the detector reports 0 across all 5228 Polish strings in core.
Caught a FALSE FRIEND that the value===key rule would have hidden:
"Data" was initially filed as an identity string, but Polish "Data"
means DATE -- core itself translates "Date" -> "Data". Left untranslated,
the object's data tab would have read "Date" to a Polish user and
collided with core's own term. It is now "Dane". Audited the key across
all nine finished locales: it/pt/es correctly carry Dati/Dados/Datos,
and sv/da/nb correctly leave it as identity because their word for date
is dato/datum. Polish was the only locale affected.
Orthography follows Swedish, not Danish/Norwegian: the bundle
capitalises domain terms mid-sentence (Rejestr 35:2, Schemat 37:1,
Obiekt 79:3), so those stay capitalised through all case inflections
(Rejestru, Schemacie, Obiektów). But "organizacja" measures 0:18 and
stays lowercase -- a per-word exception, not a blanket rule.
Harvest corrections (5 of 47 candidates wrong in context, plus 1 dropped):
- "Right" -> Uprawnienie; core's "Do prawej" means "to the right".
- "View" -> Wyświetl; core's "Podgląd" is the NOUN preview, but this
is a verb button (OrganisationsIndex.vue:90).
- "Revoke" -> Unieważnij; core's "Cofnij" means UNDO, which is not
what revoking a token does.
- "Link" -> Powiąż; the harvest gave the noun "Łącze" for a confirm
button (LinkObjectDialog.vue:62).
- "Mappings" -> Mapowania, not the Polglish "Mappingi".
- "Status" dropped to identity: identical in Polish and already used
10x in the bundle; openconnector's "Stan" is reserved here for Health.
Accepted core where it is in-domain even when the literal reading is odd:
"Bucket" -> "Kosz" (files_external IS the S3 config UI), the same call
made for Norwegian's "Bøtte". Polish core renders Trash as "Usunięte
pliki", so there is no collision. "Host" stays untranslated per core.
The {plural} source bug degrades further here: with three plural forms a
parenthetical cannot cover the genitive, so Obiekt(y) / Rejestr(y) /
Schemat(y) / plik(i) / log(i) are a documented approximation. The real
fix is for the caller to use n() instead of interpolating a literal "s".
Every string the frontend reaches via t()/n() now has a real Czech
translation. 985 new entries, 16 English placeholders replaced, 13
identity strings dropped so the runtime falls back to the source. No
pre-existing translation was altered.
Register: FORMAL -- the first formal-target locale since French, so the
detector polarity flips back. Measured against core: 177 vy/váš hits,
and all 6 apparent informal hits are the plural DEMONSTRATIVE "ty"
meaning "those" ("pouze ty stávající" = "only those existing"), not the
2sg pronoun. So core is 177 : 0 genuinely informal.
The old detector was /(Tvůj|Tvoje|Tvá)/ -- three possessive forms and
nothing else. That missed where Czech formality actually lives: the
IMPERATIVE ENDING. Formal is 2nd-person PLURAL in -te (Vyberte, Zadejte,
Spravujte); informal is the bare 2sg stem (Vyber, Zadej, Spravuj). So
"Vyber registr" is informal address with no pronoun present at all --
the same blind spot Spanish had, in a different language family.
Rebuilt with the full possessive paradigm plus a curated bare-imperative
list. 22 controls pass and the detector reports 0 across all 5005 Czech
strings in core.
Bare "ty" is deliberately NOT matched. Unlike Polish Państwo, where a
mid-sentence-capital rule separates the two readings, Czech informal "ty"
and demonstrative "ty" are identical in case and position, so no rule can
tell them apart. The possessives and imperatives are unambiguous, so
nothing is actually lost -- documented in the detector comment.
Second nplurals=3 locale, but a DIFFERENT rule from Polish: Czech splits
1 / 2-4 / 5+ where Polish keys on n%10. Verified at runtime that all six
plural keys carry three forms matching the declared expression
(objekt / objekty / objektů).
The bundle's own style, followed throughout: formal -te imperatives for
instructions, plus INFINITIVES for button labels (Zobrazit, Smazat,
Obnovit, Filtrovat), which are register-neutral in Czech and must not be
"corrected" to imperatives. Impersonal "Nepodařilo se" for failures and
"Při ... došlo k chybě" for errors, both already established here.
Orthography follows Danish/Norwegian, not Swedish/Polish: domain terms
stay lowercase mid-sentence (registr 0:35, schéma 0:41, objekt 1:79).
Bundle consistency over core once: the bundle uses "notifikace" (3:0)
where core prefers "oznámení". Kept the bundle's term.
Established terms adopted: ścieżka -> "auditní záznam" (audit trail),
"schránka" (clipboard), "mezipaměť" (cache), "měkce smazané" (soft
deleted), and core's "Hostitel" for Host and "Profilový obrázek" for
Avatar.
Harvest corrections (2 of 45 candidates wrong in context):
- "Right" -> Právo; core's "Vpravo" means "to the right".
- "Link" -> Propojit; the harvest gave the noun "Odkaz" for a confirm
button (LinkObjectDialog.vue:62).
Also translated "Test" rather than treating it as identity: Czech buttons
take infinitives here, so the webhook action reads "Testovat", matching
"Testovat připojení" elsewhere in the bundle.
"Data" stays identity, and this was checked rather than assumed after the
Polish false friend: Czech "data" IS the word for data, because Czech
uses "datum" for date. The trap is Polish-specific.
Fills every string the frontend reaches through t()/n() with a real
Russian translation. 2011/2011 keys, 0 absent, 0 placeholders,
0 register violations, 0 plural-arity errors.
Register: formal, measured rather than assumed. Nextcloud core ru
carries 328 formal pronouns and 164 formal 2pl imperatives against
ZERO of either informal marker across 3905 strings -- the least
ambiguous reading of any locale so far.
Rebuilt the register detector, which previously covered only five
nominative possessives. Russian informal address hides in three
places a pronoun check misses:
* the oblique cases (тебя/тебе/тобой and declined твой), which is
most of what running prose actually uses;
* the imperative ending -- formal is 2pl -ите/-йте (Выберите),
informal the bare 2sg (Выбери), so "Выбери реестр" is informal
with no pronoun present at all. Same blind spot Czech had;
* the 2sg present -ешь/-ишь (хочешь, увидишь). Feminine soft-sign
nouns end in -чь/-щь/-ышь/-ушь (ночь, помощь, мышь, тушь), never
-ишь/-ешь, so the ending is unambiguous.
вы/вам/ваш are deliberately NOT matched: lowercase вы is the ordinary
polite address here, not a plural-only form, so it is evidence of
nothing. 32/32 controls pass, 0 hits on core.
First non-Latin-script locale, so the --latin script-coverage check
replaces the --hybrids check. It started at 24 hits; 16 were genuinely
untranslated English (the entire browser/VAPID web-push block, plus
Slug) and are now translated. The 11 that remain are reviewed-benign:
every word of prose is translated and the Latin run is a literal --
a file path, an API field name (conversationId, fileCollection), or a
product name (Zookeeper). Byte-majority cannot tell those apart from
an untranslated string.
Harvest review caught four core/sibling values that were wrong in
sense for this app's context and would have passed every automated
check:
* Right -> "По правому краю" (right-ALIGNED) where the key is a
permissions-table header. Now "Право".
* View -> "Режим просмотра" (view MODE) where the key is an action
button. Now "Просмотр".
* Open -> "Открытый" (the adjective, harvested from circles) where
the key is an action button. Now "Открыть".
* Search -> "Найти" (the verb) where the key is a tab/field label,
and the bundle already reads "Поиск / Представления". Now "Поиск".
Also corrected Link (noun -> "Привязать", it is a confirm button),
People ("Люди" -> "Персоны", it labels the PERSON entity type),
Mappings (dropped a sibling app's "(Mapping)" gloss), and the two
Dashboard strings to the bundle's own "Дашборд" rather than core's
"Панель управления" -- bundle-internal consistency outranks core.
Bucket keeps core's literal "Корзина" from files_external even though
Russian cloud docs prefer "бакет", applying the same in-domain-core-
wins rule used for Polish "Kosz" and Norwegian "Bøtte". The bundle has
no other Корзина string, so nothing collides.
One pre-existing mistranslation fixed: Test was "Тест" (the noun) on
what is a webhook test BUTTON; now "Проверить".
nplurals=3 with a third distinct rule -- Russian keys form 0 on
n%10==1 && n%100!=11, so the arrays were built against the ru
expression rather than copied from Polish or Czech. All 6 plural keys
carry 3 forms.
22 keys are left ABSENT as identity strings (ID, Id, ID:, URL, Url,
UUID:, CSV, PDF, RBAC, DSAR, Deck, Excel/OpenDocument format names,
API-key prefix hints, literal header/YAML examples). OC.L10N falls
back to the English source, which renders the same correct text --
writing them as value===key would be indistinguishable from an
untranslated placeholder and would never get revisited. Slug was NOT
treated this way: a lone Latin word in a Cyrillic UI reads as
untranslated, so it is "Слаг".
The five object{plural}-style keys remain parenthetical approximations
("объект(ы)"). Three-form agreement means a parenthetical cannot cover
the genitive; the real fix is for the caller to use n() instead of
interpolating a literal "s".
l10n/ru.json (backend catalogue) untouched.
Both were caught by cross-locale probes while resolving the same keys for Russian, and both survive every automated check because the values are real words that differ from their keys. nl: Right was "Rechts", which is the DIRECTION "right". The key is a column header in the organisation permissions table (src/modals/organisation/EditOrganisation.vue:288), so it means a permission. Now "Recht". Every other locale already had the noun (Recht / Droit / Derecho / Diritto / Direito / Rättighet / Rettighed / Rettighet / Uprawnienie / Právo / Право). cs: Uses and Used by were BOTH "Používá". Those are two separate tabs on the object view (outbound vs inbound relations, ViewObject.vue:254 and :290), so the pair rendered identically and the user could not tell which direction a tab showed. Used by is now "Používáno v". No other locale collides on this pair.
Brings the l10n/*.js toolchain into the repo: a shared library plus four
CLIs — l10n-ai.js (key CRUD), check-l10n.js (audit en.js against src/),
clean-l10n.js (remove unreferenced keys) and find-unwrapped.js (find
prose that was never wrapped in t()).
These existed untracked, and enter the repo with four defects fixed. All
four were the kind that stay invisible until they cost you data or a
review cycle.
n() was invisible to the usage scanner. collectUsedKeys and
findKeyReferences matched only `\bt\s*\(`, so every plural key came back
unreferenced despite live call sites. That armed clean-l10n.js: it
deletes en.js-minus-used from ALL 37 locale files, so adding the plural
source keys to en.js — which is correct and expected — would have made
the next --apply erase them everywhere, including populated plural
arrays. Demonstrated against a fixture before fixing. The three scripts
had three separate copies of the extractor; they now share one that
handles t(), n() (BOTH key arguments) and the $t/$n template variants,
while rejecting identifiers that merely end in t or n (format(, fn(,
min(). As a direct consequence `rm` now correctly refuses to delete a
key referenced only from an n() call.
serializeJs reformatted every file it touched. It emitted tabs,
"key": "value", a trailing comma and `)`, where the shipped files use
four spaces, `"key" : "value"`, no trailing comma and `);` — so a
one-key edit produced a ~4400-line diff. The key order was wrong too:
localeCompare matches ZERO of the 37 files, case-insensitive code-unit
order matches 36, and localeCompare varies by Node/ICU version, which
made the sort order depend on who ran the tool. Round-trip is now
byte-identical for 36/37 files; en.js is the lone outlier, still in the
original extraction order, and will re-sort once on first write.
The eslint pass was destroying the format it was meant to normalise.
Both writers ran `eslint --fix` on the locale files, and l10n/ is not
ignored — l10n/cs.js alone reports 9760 fixable "errors". The fix
rewrites the file to tabs and SINGLE quotes, undoing the serializer
immediately and diverging from what Transifex regenerates. Locale files
are generated data, not source code, so runEslintFix is gone.
find-unwrapped.js hung forever, which is why it could never be wired
up. A bare '<' in template text ("5 < 10") is rejected as a tag open and
falls through to the text branch, whose loop stops immediately because
it is already sitting on '<' — the region is empty, the index never
advances. Now completes over the full tree in ~0.1s. Two further fixes
there: the app id no longer defaults to the hardcoded literal
'opencatalogi' (a different app — a wrong app id makes every wrapped
string look unwrapped), and looksLikeProse no longer discards
"Creating..." / "Loading..." / "Saving...", which its dotted-identifier
filter matched via the trailing run of dots. That last one was
suppressing the single most commonly unwrapped class of label.
Verified: add/set/rm/remove round-trip byte-identically and produce
one-line diffs, `set` still refuses plural arrays, `rm` still blocks on
live references, and all five files are lint-clean.
… npm
Extends the parity gate with the two checks that would have caught this
translation effort's real failures, wires the tooling to npm, and
replaces the l10n guidance.
The parity gate's central assumption was backwards. Its comment read
"Values identical to English are allowed (cognates / proper nouns /
acronyms are legitimately the same) and only counted." But absent and
identical are OPPOSITES, not degrees of the same problem:
absent -> OC.L10N falls back to the English source, so the UI
renders correct text AND the gap stays visible to tooling,
keeping the key on the work list.
identical -> renders the same characters but is indistinguishable from
finished work, to tooling and to the next maintainer, so
it is never revisited. A permanent invisible hole.
Identical is therefore the worse of the two and is the one worth gating.
This is exactly how ru shipped 24 untranslated English strings behind an
otherwise clean report. Cognates now belong ABSENT rather than written
out; --allow-identical restores the old tolerance for a bulk migration.
Also added: plural arity against each locale's OWN declared nplurals.
That is the one l10n defect invisible to reading the file — OC.L10N
indexes the array with the plural expression's result, so a short array
renders blank for some counts. Note arity alone is not sufficient
protection: ru, pl and cs all declare nplurals=3 with three mutually
incompatible expressions, so a Polish array pasted into Czech has the
right length and the wrong boundaries.
npm wiring: test:l10n:parity, check:l10n, clean:l10n, find:unwrapped.
The last three were documented but had never existed as npm scripts, so
every command in the old guidance failed.
CLAUDE.md was an unedited copy from opencatalogi: the wrong app id
throughout (a wrong id fails lookup silently and renders untranslated
text with a green pipeline), three npm scripts that did not exist, and
it forbade touching l10n/*.json — the file the sanctioned extractor
actually writes. Rewritten with the verified commands, the two
translation sets described as the independent catalogues they are, and
the rules established across 12 completed locales.
One obsolete rule deliberately reversed: the old text said never to
narrow `add --locales` and never to defer a locale. Written for a
two-locale app, that now demands 37 hand-written values per string and
invites precisely the placeholder filler the value===key rule forbids.
`en` is required; the rest are optional and better left absent.
The per-language method — measuring formality register against Nextcloud
core instead of assuming it, why harvested values must be checked at the
call site, plural incompatibility, and the established per-locale
conventions — moved to docs/l10n-ui-translation.md so it is read on
demand rather than billed on every call.
readStringLiteral handled only \n, \t and \r; every other escape fell
through to `else value += n`, which drops the backslash and keeps the
letter. So the source literal
t('openregister', '⚠️ PERMANENT DELETION WARNING ...')
extracted as the key "u26A0uFE0F PERMANENT DELETION WARNING ...", while
at runtime JS produces "⚠️ PERMANENT DELETION WARNING ...". The two
never match, so any translation stored under the extracted key is dead
on arrival, and check-l10n reports the real key as missing forever.
The 12 finished locales happen to hold the correct emoji key, so nothing
shipped broken -- but the tooling could not see that, and reported those
two keys as untranslated in every locale.
Decode \uXXXX, \u{XXXXX} and \xXX, and add the remaining single-letter
escapes (\b, \f, \v, \0) so the extracted key is byte-identical to the
runtime key. Verified against seven literal forms, including the ⚠️ /•
case and a surrogate-pair \u{1F600}.
1985 of 2011 frontend keys now carry a real Ukrainian translation, up
from 1005. The remaining 26 are deliberate: acronyms and formats
identical in Ukrainian (ID, URL, UUID:, CSV, PDF, RBAC, IBANs), proper
names (Deck, Excel (.xlsx), OpenDocument (.ods)), literal placeholder
examples (sk-..., org-..., fw_..., myapp, example URLs, header/YAML
samples) and one pure-placeholder format string. They are left absent
rather than written out, so the runtime falls back to English and the
keys stay visibly untranslated.
Register: formal, measured against Nextcloud core rather than assumed.
Across core/lib/apps uk.json, 632 distinct strings carry formal markers
(ви/ваш, 2pl imperatives in -іть/-те) against 2 informal, and both of
those are deliberately casual content (a user-status prompt and a sample
calendar event) rather than UI chrome. Detector validated on 22
must-fire / must-not-fire controls; it finds 0 informal markers in the
finished uk.js. Matching core, ви/ваш is used for address and possession
and actions are infinitives (Додати, Зберегти, Переглянути).
Harvested 24 values from core/lib and bundled apps, ranked core first.
Three were correct translations of the wrong sense and were rewritten
after checking the call site:
People PERSON entity-type label, not "Users" -> Люди
View row action button, not display mode -> Переглянути
Bucket histogram score range, not basket/bin -> Діапазон
Right (permission column, not text alignment), Subject (GDPR data
subject, not mail subject) and Open (NcButton verb, not adjective) were
checked against the same trap list and translated in their real sense.
Plurals use Ukrainian nplurals=3 (1/21 | 2-4 | 5-20,0); all 6 plural
keys carry 3 forms. The object{plural} family follows the parenthetical
convention already used by ru and cs -- об'єкт(и) -- because the source
interpolates a literal "s" instead of calling n().
Verified: 0 value===key, 0 bad plural arity, 0 informal markers, no
Latin-only values, loads under OC.L10N.register with the correct
plural-forms header, and diffing against the previous file shows 988
keys added, 8 value===key cognates removed, 15 placeholders replaced,
and 0 existing real translations altered.
extractTCalls pushed BOTH arguments of an n() call into the used-key set, so every plural source string was compared against en.js as if it were a catalogue key of its own. It never is: an n() call has two source strings but one key -- the singular -- and the plural lives in that key's value array. The six plural sources were therefore permanently reported as missing, and no amount of correct translation could clear them. Track plural source -> singular key while extracting, and treat a plural source as satisfied when its singular key holds an array. check:l10n now reports 0 missing instead of 6 unfixable ones.
Six strings in two ternaries rendered English for every user despite five
of them already being translated in all 13 finished locales -- the
literal was simply never passed through t():
ViewObject.vue isCopied ? 'Copied' : 'Copy'
isSaving ? ('Creating...' | 'Saving...')
: ('Create' | 'Save')
Copy, Creating..., Saving..., Create and Save were all already in the
catalogue and translated; only Copied is new.
Also wraps "Mode:" and "Error Details" in MassValidateModal. Those two
mattered beyond the display bug: both keys existed in en.js with no t()
call, so they read as dead and were on the unused-key removal list.
Wrapping them keeps their translations rather than discarding work that
would be needed the moment the string was wrapped.
t() is available in these templates via main.js's
app.mixin({ methods: { t, n } }).
Static extraction cannot see a key passed to t() through a variable:
t('openregister', action) PermissionMatrix.vue:41
t('openregister', step.status) ApprovalStepList.vue:17
t('openregister', preset.label) DashboardIndex.vue:91,120,360
t('openregister', key) MainMenu.vue:76 (manifest labels)
All four are real, live keys. actions and the date presets are hardcoded
frontend arrays; step.status is a raw DB enum that the approval-steps API
returns verbatim, so the backend never localises it and the frontend must.
They therefore look unused. Once en.js was completed to cover them,
clean-l10n --apply would have deleted 17 keys from all 37 bundles,
silently un-translating the Permission Matrix headers, the approval
status badges, the dashboard date presets, and the "Data sources" and
"Endpoints" menu labels.
Adds DYNAMIC_KEYS + collectDynamicKeys() to lib/l10n.js, documenting
where each key comes from, and teaches both consumers to treat them as
used: check-l10n no longer reports them unused, clean-l10n never offers
them for removal. clean-l10n now prints the protected count so the
exclusion is visible rather than implicit.
en.js had drifted badly from src/: 1410 keys where the code uses ~2000,
so check:l10n reported 997 missing and 405 dead and neither number could
be trusted as a completeness signal for any locale.
en.js is now generated from the actual t()/n() call sites and is a strict
superset of every locale: 2018 keys. The six n() keys hold proper
[singular, plural] arrays instead of being absent, and the 15
variable-keyed strings were added here rather than deleted from the
locales, because they are genuinely used (see previous commit).
Dead keys removed from all 37 bundles (13,483 entries), all verified to
have no t() reference and no complete quoted literal in src/ -- obsolete
features: agents, conversations, collections, Solr/Zookeeper, memory
prediction. Also removed 240 keys that existed in a locale but not in
en.js at all, which is backwards -- a translation for a string the source
does not contain: nl's entity-type map keys (PERSON/EMAIL/... are JS
object keys in formatType, not translation keys), three PHP %1$s
notification strings that belong to the backend .json catalogue, two
pre-fix mangled ⚠ variants, and 226 obsolete SOLR/agent keys in tr.
The 13 finished locales (nl de fr es it pt sv da nb pl cs ru uk) are now
key-for-key identical to en.js -- 2018 keys each, 554 cognates written
out explicitly. This reverses the earlier "leave cognates absent" rule
for these locales only; the 23 unfinished ones keep their current shape
so their real progress stays measurable. Note the consequence:
test:l10n:parity now reports 22-70 English-identical per finished locale
where it previously reported them as missing. Those counts are the
cognate counts, not defects.
Wrong-sense and gap fixes found by cross-checking the finished locales
against each other. Most one-off absences are legitimate -- French really
does share Action/Configuration/Contacts with English, Dutch shares
Object/Complex, German shares Name/Status -- so each was judged per
language rather than by majority vote. The genuine errors:
Bucket WRONG SENSE everywhere. It labels a histogram score range,
but nb had "Bøtte", pl "Kosz" and ru "Корзина", all
"basket/pail". Now a range in all 13. These are the only
three pre-existing translations this commit overwrites.
Object A/B, Object #{id} absent in de and fr, which render Object as
Objekt/Objet, so these showed English.
Multitenancy, GitHub/GitLab Personal Access Token absent in de, fr.
Name *, Name* absent in fr, which has Name -> "Nom".
Facetable absent in es; log{plural} absent in es and pt.
Account absent in pt, sv. Endpoints absent in pt. Agents absent in nl.
Copied new key, translated for all 13.
Verified: en.js is a superset of all 36 locales, the 13 finished ones
have identical key sets, 0 bad plural arity anywhere, every bundle loads
under OC.L10N.register with plural arrays matching its own nplurals, and
diffing against HEAD shows 0 real translations altered beyond the three
Bucket fixes above.
el now carries a real Greek translation for every string that needs one:
1007 keys added and 15 English placeholders replaced, taking it from
1011 to 2018 keys -- key-for-key identical to en.js, matching the
full-sync shape of the other finished locales. The 26 remaining
English-identical values are deliberate cognates: acronyms and formats
Greek keeps as-is (CSV, PDF, RBAC, URL, UUID:, IBANs, DSAR, Slug,
Webhook, Email -- core Greek also renders Email as "Email"), proper
names (Deck, Excel (.xlsx), OpenDocument (.ods)) and literal placeholder
examples (sk-..., org-..., fw_..., myapp, sample URLs, header/YAML
snippets).
Register: formal, measured against Nextcloud core rather than assumed.
Core/lib alone gives 3 informal vs 135 formal distinct strings; with all
bundled apps, 8 vs 541. The 8 informal hits are demo content ("Γεια σου
κόσμε!"), the standalone "Εσύ" label, and one residual 3sg-past false
positive that itself contains formal σάς. So σας/εσείς for address, 2pl
imperatives in -τε (Επιλέξτε, Πατήστε, Εισάγετε) and 2pl present
(Μπορείτε, Έχετε).
Building that detector took three corrections, because the naive version
reported 532 informal vs 639 formal -- effectively noise:
σε read as the 2sg clitic, but it is overwhelmingly the
preposition "to/in" (351 hits). Dropped.
-εις / -άς matches plural NOUNS (ειδοποιήσεις) and genitive
singulars (γραμματοσειράς), not just 2sg verbs. Replaced
with a closed verb list.
-σε verbs the 2sg imperative is homographic with the 3sg past: "Ο
{actor} δημιούργησε" is "created", not "create!". Now
requires no sentence-initial 3rd-person subject -- and
that cue had to be anchored to the start, because mid-
sentence "το" is the neuter article ("πάτησε το κουμπί").
Validated on 19 must-fire / must-not-fire controls, including those
false-positive strings; the finished el.js has 0 informal markers.
Convention follows core Greek: actions are verbal nouns (Αποθήκευση,
Διαγραφή, Προσθήκη, Επεξεργασία), not imperatives. Glossary: Μητρώο
(register), Σχήμα, Αντικείμενο, Οργανισμός, Διακριτικό (token), Τελικό
σημείο (endpoint), Ιστορικό ελέγχου (audit trail), Όψη (facet),
Απόκρυψη (redaction), Εγγραφή αναφοράς (golden record).
Harvested 24 values from core/lib and bundled apps. Bucket was the
familiar wrong-sense trap -- files_external offers "Κάδος" (bin/basket)
where the string labels a histogram score range, so it became "Εύρος".
People correctly harvested as "Άτομα" here (unlike uk, where core gave
"Users"), and Right/Subject/Open were translated in their verified
senses: Δικαίωμα (permission, not direction), Υποκείμενο (GDPR data
subject, not mail subject), Άνοιγμα (action, not adjective).
Plurals use Greek nplurals=2; all 6 plural keys carry 2 forms. The
object{plural} family follows the parenthetical convention already used
by ru/cs/uk.
Verified: 0 missing, 0 empty, 0 bad plural arity, key set identical to
en.js, loads under OC.L10N.register, and diffing against HEAD shows 0
existing real translations altered or removed.
fi goes from 1011 to 2018 keys -- key-for-key identical to en.js -- with
1007 keys added and 15 English placeholders replaced. The 24 remaining
English-identical values are deliberate cognates: acronyms and formats
(CSV, PDF, RBAC, URL, UUID:, IBANs, DSAR, Slug, Webhook), proper names
(Deck, Excel (.xlsx), OpenDocument (.ods)) and literal placeholder
examples.
Register: 2sg (sinuttelu), and this is the first locale in this effort
that is NOT formal -- so it was worth measuring rather than carrying the
previous locales' answer over. Finnish does not map onto the Slavic/Greek
T-V pattern, and core is unambiguous: the formal pronoun te/teidän has
ZERO hits in core+lib, while sinä and the 2sg possessive -si are
pervasive ("salasanasi", "Kirjautumispolettisi"). core+lib scores 2sg 138
vs 2pl 5; with all bundled apps, 554 vs 31, and the 2pl residue is
false-positive: -kaa/-kää also forms A-infinitives and 3sg ("Haku alkaa"
= search begins), so that ending is not usable as a marker and a closed
verb list is used instead.
Because 2sg is correct here, the register detector is INVERTED relative
to el/uk/ru: it flags 2pl, not 2sg. Validated on 23 must-fire /
must-not-fire controls -- including the -kaa false positives and correct
2sg forms that must never be flagged -- and the finished fi.js has 0
formal-2pl markers.
Convention follows core Finnish: buttons and actions are 2sg imperatives
(Tallenna, Poista, Peruuta, Muokkaa, Luo, Lisää, Kopioi), the exact
opposite of Greek's verbal nouns. Error messages take the natural Finnish
nominal shape ("Asetusten tallentaminen ei onnistunut") rather than a
literal "Failed to ...". Token is "poletti", matching core's
"Kirjautumispolettisi".
Harvested 22 values from core/lib and bundled apps. Revoke needed
correcting: settings offers "Peru oikeus", which is permission-specific,
but the call site revokes an API token -> "Mitätöi". Bucket was absent
from the Finnish harvest entirely, so it was translated fresh as "Väli"
(range) rather than inheriting the basket/bin sense that was wrong in
nb/pl/ru. People correctly harvested as "Ihmiset" for the PERSON entity
type; Right/Subject/Open translated in their verified senses (Oikeus,
Rekisteröity, Avaa).
Plurals use Finnish nplurals=2; all 6 plural keys carry 2 forms.
Verified: 0 missing, 0 empty, 0 bad plural arity, key set identical to
en.js, loads under OC.L10N.register, and diffing against HEAD shows 0
existing real translations altered or removed.
These labels live in src/manifest.json and reach t() only through CnAppNav's `translate` prop (MainMenu.translate), so static extraction never saw them: Administration, Audit, Data quality, Documentation, Features & roadmap, Integration, Search / views. They were absent from en.js and from all 36 locale bundles, i.e. the top-level navigation groups have been rendering in English in every language. Also narrow collectDynamicKeys() to the manifest fields that are actually translated. It previously harvested every label/name/title in the manifest, which pulled in observability.metrics[].name (Prometheus metric identifiers such as objects_created_total) and pages[].title, which CnPageRenderer forwards to the page component as a raw prop without translating. Only menu[].label (recursed through children) and the two nav label overrides reach t(). en.js and the 16 completed bundles are now 2025 keys, key-for-key identical, with no extra keys in any locale.
The webhook headers placeholder is a code example, not UI copy, so it
does not belong in t(). Unwrapping it makes
"X-Custom-Header: value\nAuthorization: Bearer token" a dead key, so it
is dropped from en.js and all 36 locale bundles. It was value===key in
every one of them, so no translation is lost.
Also fix nl "file{plural}", which was left as "bestand{plural}". The
source interpolates plural: count !== 1 ? 's' : '', an English plural
marker, so that rendered "bestands"; Dutch is "bestanden". Its siblings
already sidestep this as "logboek(en)" / "object(en)", so this follows
them with "bestand(en)". nl "register{plural}" -> "registers" is left
alone because the English -s happens to be correct Dutch there, as it is
for es and pt throughout.
Note the underlying source defect this exposes: hardcoding 's' is only
correct for languages that pluralise with -s. Turkish (-lar/-ler) still
renders "dosyas"/"nesnes", and it cannot work at all for Finnish
partitives, Hungarian (no plural after a numeral) or the three-form
Slavic plurals. These call sites should use n() with a real plural key.
hu.js goes from 1011 to 2024 keys, key-for-key identical to en.js: 1013
added, 16 English placeholders replaced with real translations, and 23
deliberate cognates (Audit, CSV, PDF, RBAC, Id, Port, URL, format names,
and literal example values shown verbatim in inputs).
Register: Hungarian core is formal. The measurement is unambiguous —
core+lib+apps has 43 hits for Ön/Önnek/Önt against 3 for te, and every
instructional string uses the polite third-person imperative
("Kattintson", "Lépjen", "szerkessze"). Formal Hungarian also takes the
3sg possessive, so "your password" is "a jelszava", never "a jelszavad".
Validated with a closed-list detector (2sg pronouns, 2sg verb forms, 2sg
possessives) over 10 must-fire and 28 must-not-fire controls; suffix
matching is unusable here because word-final -d and -sz are also the
natural endings of kód/mód/rend/föld and húsz/ész/dísz.
Conventions follow core: buttons are -ás/-és verbal nouns (Mentés,
Törlés, Létrehozás, Hozzáadás), not imperatives; quotes are the low-high
pair; plural arrays carry the same form twice, since Hungarian does not
pluralise after a numeral.
Domain terms match the 1011 strings already in the bundle:
Nyilvántartás, Séma, Objektum, Forrás, Végpont, Szervezet, Ügynök. GDPR
wording uses Hungarian statutory terms (érintett, jogalap, megőrzési
idő, elszámoltathatóság, adathordozhatóság), and the Dutch source terms
are rendered the same way de/fi/el handle them, keeping Autoriteit
Persoonsgegevens as a glossed proper name.
One pre-existing value corrected: "Contacts" held "Kapcsolatok"
(= connections), but its only call site is RelationsTab.vue's entity-type
map for address-book contacts, and "Relations" already owns
"Kapcsolatok" — the two were indistinguishable in the UI. Core uses
"Névjegyek" (apps/dav/l10n/hu.json), which also matches the "névjegy"
wording used throughout the rest of the bundle.
Verified: key set identical to en.js, 0 empty values, 6 plural keys all
at nplurals=2, placeholders preserved in both directions, 0 informal
forms against 122 explicitly formal ones, 0 of the 1011 pre-existing
translations lost or altered apart from the documented Contacts fix, and
the bundle loads under OC.L10N.register.
cs is one of the sixteen locales finished before any of this tooling existed
(§9.2), so it had never had a register measurement, a detector, a cognate review
or a grammar pass. This does all four and audits all 2052 values, not a
pre-existing half.
THE HEADLINE IS THAT cs IS HEALTHY, and it is worth stating because it
contradicts what the re-audit was set up to expect. These sixteen are DOUBLY
un-audited, so the prediction was that they would be as bad as is or worse:
is (pre-existing half) cs (whole bundle)
values audited 1052 2052
defects 235 (22%) 113 (5.5%)
garbled / foreign 14 0
agreement failures 11 0
wrong plural arrays — 0
dominant class bad compounds, terminology drift and
wrong senses internal inconsistency
Czech is an actively maintained Nextcloud locale with a real translator
community and the bundle reads like it. The lesson for the remaining fifteen is
that the defect rate tracks how healthy the locale is upstream, not how long it
went un-audited — so budget these passes for terminology counting, not grammar
repair.
MEASUREMENTS, all previously assumed rather than measured:
· register FORMAL — 828 formal (vy) markers vs ZERO informal (ty) over core
cs's 32 catalogues / 5005 values, plus 243 vs 0 in the bundle's own 2052.
§8.3 says a zero deserves a second look, so it was re-checked by a raw
unguarded scan over 25 informal tokens across the combined 6685 values: all
absent. cs is the ORDINARY Slavic T-V case and that is the point — it has a
live vy/ty distinction in current use, so unlike the three locales done
before it (ga has none, mt has one and leaves it unused, is had one and
abandoned it) there is no structural story. Those three were exceptions; cs
is the baseline they were exceptions to.
· buttons INFINITIVE — 48 bare action keys resolved against core cs give 27
infinitives, ZERO imperatives, ZERO verbal nouns; the rest are legitimately
not verbs (Storno, Zpět, Settings). So the 2sg imperative can be counted as
an informal marker without flagging every button, as in sk.
· nplurals=3, ABSOLUTE boundaries (1 / 2–4 / else), agreeing with the library,
so no pluralOrder or pluralBoundary is needed. All 7 arrays were already
correct, including _Successfully restored {count} object_, which switches the
participle per form (Obnoven / Obnoveny / Obnoveno) as Czech requires.
THE DETECTOR'S BOUNDARY GUARD IS LOAD-BEARING IN A WAY NO PREVIOUS LOCALE'S WAS,
and this is the durable finding (now §8.1):
· EVERY Czech 2sg imperative is a proper PREFIX of its 2pl counterpart,
because the 2pl is the 2sg plus -te: vyber/vyberte, zadej/zadejte,
nastav/nastavte, zvol/zvolte. This bundle holds 64 "vyberte" and core 48
"zadejte", so an unguarded 2sg list scores the commonest FORMAL shape in the
corpus as informal and INVERTS THE VERDICT OUTRIGHT. Worse than the sk vy-
prefix trap, because it hits the markers themselves. Several stems are also
prefixes of the app's own nouns: nastav ⊂ nastavení, zobraz ⊂ zobrazení.
· the informal possessive "tvá" is a substring of vytvářet / vytváření ("to
create"), which a raw scan finds 48 times — every one inside that verb.
· bare ty/ti stay unmatched per §8.2, and the cost is now measured: ty occurs
6 times in the corpus, all demonstrative, and ti zero times.
· bare "si" is unmatched for a DIFFERENT reason from hr/sk/sl. There it is the
2sg of "to be" as well as the reflexive clitic, so it is ambiguous. Czech's
2sg of být is "jsi", so si is only ever reflexive — empty, not ambiguous.
· "prosím" gives no free signal: it is 1sg, so it inflects for the speaker.
66/66 controls pass.
WHAT WAS WRONG, by class (codes recorded per key in locales/cs.json):
TERM-CONFIG 32 the noun "configuration" onto konfigurace
TERM-* 28 embedding→vnoření (8), chunk→úsek (4), audit trail→
auditní záznam (3), search trail→záznam vyhledávání (4),
View entity→pohled (5), Refresh→Znovu načíst (7, core),
Validate→kontrola (3), Test→Otestovat (3), erasure→
výmaz (2), purge (1), confidence→spolehlivost (2)
CONSISTENCY-* 16 (optional)→nepovinné (5), cannot be undone→vzít zpět
(4), type-to-search family (3), API key word order (3),
Merge Operations header (1)
SENSE 7 Commit message→Zpráva commitu (read "commit" as
"confirm" in a bundle full of Git); Complex→Složitý
(komplexní is a false friend — comprehensive, not
complicated); Uses→Použití (3sg verb for an AppTab
title); falling back; "in chunks"→v dávkách
CASE 6 No register objects reference this file — lost the "na"
that odkazovat governs; Queue / sync health → "Stav
frontu" used the genitive of masculine "front" (a front
line) where a queue is feminine "fronta"→"fronty";
"událost, kterou naslouchat" put an accusative on
naslouchat, which governs the dative, with no modal;
Search GitHub/GitLab dropped the locative
DANGLING-PREP 4 "Detekováno v" / "Extrahováno v" / "Aktualizováno v"
left the preposition without an object → the bundle's
own "Datum X" column pattern
COLLISION 3 Poor==Low, Reachable==Available, Objects being
analyzed==Objects Analyzed
COGNATE-FILLER 2 Driver, N/A — see below
TYPO 2 "fazetování" for "fasetování", twice
NORMALISE 2 Id→ID, Url→URL
WORDFORM 1 "vyžadovanost" is a nonce -ost formation
THE CONFIGURATION / SETTINGS SPLIT WAS THE OWNER'S CALL. The bundle rendered the
app's Configuration entity nastavení in 33 values and konfigurace in 31, and the
split ran THROUGH individual features rather than between them, which is what
made it a defect and not a preference: the Configurations screen was titled
Konfigurace while its own buttons read "Nové nastavení" / "Upravit nastavení" /
"Exportovat nastavení"; LLM Configuration was "Konfigurace LLM" but "Loading LLM
configuration..." was "nastavení LLM"; and "Failed to save configuration" was
byte-identical to "Failed to save settings". Core cs renders the generic heading
Configuration → Nastavení, pointing the other way, so it went to the owner per
§6.4 step 2. Decision: konfigurace for the noun, nastavení for Settings —
knowingly diverging from core, because core has no Configuration ENTITY and so
its rendering does not transfer to a domain where you create, edit, export,
import and publish them. Verbs untouched; "Configure X" → "Nastavte X" cannot
collide with either noun.
COGNATE REVIEW (§9.2), 26 identical values: 22 genuine, 2 filler, 2 casing
defects. Driver was filler — almost every locale translates it (de Treiber, fr
Pilote, es Controlador, hr Upravljački program), only cs and da did not, and
core cs itself writes "ovladače databází"; N/A likewise, with sibling sk
rendering "Neuvedené". Slug by contrast is kept by twelve bundles and stays.
TWO METHOD NOTES THAT COST SOMETHING, both now in §6.9 / §9.2:
· MECHANICAL CHECKS FOUND ESSENTIALLY NOTHING HERE — ellipsis glyph, trailing
punctuation, capitalisation, number agreement, whitespace and placeholder
checks between them produced one real finding and a dozen false positives.
On is they found 4 of 239; here ~0 of 113, because this bundle's defects are
semantic rather than morphological and no checker can see that "Zpráva
potvrzení" reads commit as confirm. Counting competing renderings per
English term produced about 70 of the 113 and needs no Czech at all. Do that
first. The exact-value-collision scan was second best.
· CORE OVERTURNED FOUR CANDIDATE FIXES, and a majority inside the bundle is
not authority on its own. "Loading…" → "Načítání…" looks like the outlier
against 37 sibling "Načítá se" values and is CORE'S OWN FORM, so the one
value I was about to correct was the only one that matched core. "Current
password" → "Dosavadní heslo" looked like a wrong sense and is core
verbatim. Bucket is untranslated in core and there means an S3 bucket, so
core is no authority for this app's histogram-bin sense and the value was
left alone.
Also: CHECK THE CALL SITE BEFORE CALLING A FORM WRONG. "folder" → "složky" looks
like a genitive where a nominative belongs and is correct — the key is a button
in the middle of a split sentence whose preceding fragment ends "přejděte do",
which governs the genitive. That is the §6.9 case-governance trap exactly.
Collisions left deliberately (§8.5): Konfigurace serves Configuration and
Configurations, Organizace both Organisation forms, Akce both Action forms,
Integrace both Integration forms — in each the Czech feminine -e noun is
genuinely syncretic between nominative singular and plural, so there is nothing
to disambiguate.
Verified: selfcheck ALL CHECKS PASS (22 recorded cognates, 113 audited
corrections), runtime-check ALL RUNTIME CHECKS PASS, check:specs PASS,
test:l10n:parity OK, format clean, l10n/cs.js 2058 lines = l10n/en.js, gatetest
confirms the parity gate genuinely holds cs. selfcheck + detector controls +
runtime-check re-run green across all 16 recorded locales. test:l10n stays red at
17 keys, unchanged from HEAD and unrelated — that is the §10 / §6.15 source-side
backlog.
sk is a Tier 2 locale: it already had a measured register, a detector, a cognate
review and a terminology record, but a `corrections` count of ZERO, so the audit
was the only missing piece. It was picked next on purpose rather than another
Tier 1 locale, to test whether a 0 means "clean" or merely "unverified" — and
because it is the closest sibling to cs in the whole set, which isolates upstream
maintenance from language family.
THE ANSWER IS "MOSTLY CLEAN", and the cs lesson holds:
is (pre-existing) cs (whole) sk (whole)
values audited 1052 2052 2052
defects 235 (22%) 113 (5.5%) 57 (2.8%)
garbled / foreign 14 0 1 (a typo)
agreement failures 11 0 0
wrong plural arrays — 0 0
wrong case 19 6 0
dominant class bad compounds, terminology ONE term, plus
wrong senses drift stray one-offs
So a 0 count means unverified, not clean — there were 57 real defects nobody had
looked for. But it does NOT mean a quarter of the file is waiting. sk and cs are
both actively maintained Nextcloud locales and both read like it; the defect rate
tracks upstream health, not how long the locale went un-audited. Tier 2 is
cheaper than the is numbers made it look.
WHAT WAS ACTUALLY WRONG is unusually concentrated: 37 of the 57 are one term.
· AUDIT TRAIL, 36 keys + 1. The bundle rendered the app's audit-trail entity
as `audítny záznam` — "audit record" — which forced "audit trail entry" to
come out as `záznam audítneho záznamu`, "record of the audit record", in 8
keys, with two stray renderings beside it (`Auditná stopa` ×1,
`audítorská stopa` ×2). Escalated as the owner's call: first-class entity
noun, 30+ keys, no core authority. The owner chose to re-coin as
`auditná stopa`, so "trail" is stopa, "entry" is záznam, and the stutter
dissolves by construction instead of being patched key by key.
The pre-existing outlier `Audit trail #{id}` → `Auditná stopa #{id}` turned
out to be the ONLY key already written the chosen way and needed no change:
the outlier was the model. That is the cs `Loading…` lesson in a new shape.
The adjective was also misspelled in all 35 keys that carried it — `audítny`
with a long í, where Slovak adds -ný to the stem with no vowel change
(kredit → kreditný, limit → limitný). The long í belongs to a different
lexeme, `audítor` (Latin audītor), whose adjective is `audítorský`; `audítny`
blended the two. The bundle's own `audit`, `auditu`, `auditovanie` and
`auditujte` keep the short i, matching core sk's "Auditovanie", and it
lengthens correctly in `Audítori` — so it already had the distinction and
applied it to the noun and the verb while getting the adjective wrong.
`Audítori` is preserved untouched for exactly that reason.
· TWO TABS CARRYING EACH OTHER'S MEANING. `Uses` → `Používa sa` ("it is used")
and `Used by` → `Používa` ("it uses") were inverted. Both are AppTab titles
over opposite relation directions. Every locale checked marks the direction
(cs Použití / Používáno v, de Verwendungen / Verwendet von, pl Używa /
Używane przez); sk was the only one with the pair swapped. Fixing `Uses` also
resolved a byte-identical collision with `In use`, whose `Používa sa` is
correct as a card badge.
· A SUBJECT/OBJECT REVERSAL. "No register objects reference this file" read
`Tento súbor neodkazuje žiadne objekty registra` — "this file references no
register objects", the opposite claim. Now `Na tento súbor neodkazujú…`,
which also supplies the `na` that odkazovať governs.
· SEVEN DANGLING PREPOSITIONS in <th> column headers — `Detected At` →
`Zistené o` and five siblings left `o`/`z`/`podľa` with no object, and `o` +
locative would mean "at (o'clock)" anyway. Fixed onto the bundle's own
`Deleted Date` → `Dátum odstránenia` pattern.
· The rest are one-offs: a Czech spelling (`strategie` for `stratégie`);
`Breaking change` → `Rozbíjajúca zmena`, a literal calque where 17 of 20
locales say "incompatible change"; `Commit Message` → `Správa potvrdenia`,
reading commit as confirm, the same defect the cs pass fixed; the
`Loading organisations...` outlier, wrong on the same two counts as in ga, mt
and is; and four consistency normalisations.
CHECKING CORE BEFORE "FIXING" AN OUTLIER OVERTURNED FIVE CANDIDATES, a higher
rate than cs's four, which makes it the highest-value step in the method:
· `Refresh` and `Restore` both render `Obnoviť` — and core sk collapses them
the same way, so the collision is core's, not the bundle's.
· `First` / `Last` / `Previous` → `Prvé` / `Posledné` / `Predchádzajúce` is
core sk VERBATIM, not neuter-where-Stránka-is-feminine.
· bare `Search` → `Hľadať` is core sk verbatim in 3 catalogues, despite every
compound key in the bundle using `Vyhľadať`.
CHECKING THE CALL SITE OVERTURNED FIVE MORE, and they are worth listing because
each looked like a textbook defect:
· `Handler` → `Riešiteľ` is right: `c.handler` is a person, an AVG case worker.
· `Fair`/`Good`/`Poor` → neuter `Uspokojivé`/`Dobré`/`Slabé` is right: they are
KPI labels over `skóre` (neuter), so they need not match the feminine
`Vysoká`/`Stredná`/`Nízka` confidence family.
· `Filter Statistics` → `Filtrovať štatistiky` is right: it is an h3 heading
OVER filter controls, so the infinitive action-label rule applies.
· `Requested at` → `Požiadané` and `Expires` → `Vyprší` are not dangling — the
template supplies the colon and a date follows.
DELETE/REMOVE WAS ESCALATED AND DELIBERATELY LEFT. The bundle renders both as
`Odstrániť` across 122 values (88 Delete, 41 Remove). Core sk splits them
cleanly — Delete → `Zmazať`(6)/`Vymazať`(3) and never `Odstrániť`; Remove →
`Odstrániť`/`Odobrať` — and `Zmazať` was the only free slot, since the bundle has
already spent `Vymazať` on Clear and on the GDPR Erase/`vymazanie` family, where
it is the standard term for the Art 17 right and cannot move. The owner chose to
leave it: both are valid Slovak, the collision is soft because the two actions
rarely share a view, and §3.8 protects an existing real translation from a change
of taste. Recorded in locales/sk.json as a deliberate divergence from core, with
the counts, so the next reviewer neither re-litigates it nor mistakes it for an
oversight.
METHOD NOTE: mechanical morphology checks were NOT written. Term counting showed
no morphological drift to chase, and the runbook's own numbers (4 of 239 on is,
about 0 of 113 on cs) say to skip them. Reading every value found the typo, both
reversals and all seven dangling prepositions — everything no checker can see.
Verified: selfcheck and runtime-check ALL PASS for sk; check:specs, parity and
format green; sk.js 2058 lines, equal to en.js; gatetest confirms the parity gate
genuinely holds sk. selfcheck + runtime re-run across all 16 recorded locales
(tr ca et hr lt lv ro sk sl bg sr rm ga mt is cs) — 0 failures. test:l10n is
still RED at 17 keys, unchanged: proved by `git stash -u`, re-run, compare, pop,
not assumed. That failure is the pre-existing §10 / §6.15 source-side defect and
is unrelated to this pass.
…of its cost
The sk audit took a whole session for 57 corrections over 2052 values, and almost
all of that went into two things that did not have to be slow: reading every
value in sequence, and forming candidate corrections that were then killed. These
three reports attack both. Every yield figure below is MEASURED against sk's 57
known corrections and against is as it stood before its own audit — not estimated.
core-diff.js pre-empts 6 of 6 false candidates
termdrift.js surfaces the term behind 37 of 57
spell.js 1 of 57 on sk; 5 of 5 garbled words on is
(+ the existing §6.9 dangling-preposition regex: 7 of 57)
Together they reach roughly 48 of sk's 57 from a few hundred lines of report
rather than 2052 values of prose.
CORE-DIFF IS THE ONE THAT MATTERS MOST, and not because it finds defects — it
stops you inventing them. Both the cs and sk passes checked core only AFTER
forming candidates, and core then overturned four and six respectively. On sk:
Refresh/Restore (core collapses them onto Obnoviť exactly as the bundle does),
First/Last/Previous and bare Search (core ships the bundle's wording verbatim).
Each looked like a textbook defect on grep evidence alone. All six sit in this
report's AGREE list, which is to be read as "never question these" — so the
whole false-candidate round disappears. Delete → Zmazať also lands at the top of
DISAGREE, i.e. the pass's biggest terminology decision surfaces in the first
minute instead of an hour in.
TERMDRIFT REMOVES THE GUESS FROM §6.9. That section already said to count
competing renderings first, and it produced ~70 of cs's 113 corrections and 41 of
is's. But all three passes counted BY HAND against a guessed term list — register,
schema, file, audit… On sk the term that had actually drifted was found only
because `audit` happened to be on the guess list. This indexes every English
content word instead. On the pre-audit sk bundle it prints 42 entries, one being:
"trail" — 15/16 keys use "zazna-", 1 do not:
"Audit trail #{id}" "Auditná stopa #{id}"
That single line is the entry point to 37 of the 57 corrections. Note it points at
the MINORITY side — which is the side the owner then chose, and which became the
convention for the other 36 keys. The tool surfaces the split; it does not and
must not pick the winner.
SPELL IS FOR WRONG-LANGUAGE CONTAMINATION, the class a reader's eye slides over.
Against is as it was before its audit it catches all five words that pass found by
reading, including the two the docs single out as proof the defects are not merely
stylistic: Stav (Slavic, in an Icelandic bundle) and skrivaðgang (a Danish stem
where Icelandic needs skrifaðgang). On sk it catches the one typo, strategie, and
suggests exactly stratégie.
Dictionaries come from LibreOffice's repo via fetch-dicts.js, NOT from the distro.
Arch/CachyOS official repos carry dictionaries for only ~10 of our 36 locales —
sk, cs, sl, hr, bg, lt, lv, et, is, ga, mt and every Nordic language are absent —
and package names differ per distro, so "install the dictionaries" is not a
reproducible instruction. The repo route covers 30 of 36, needs no root and pins
identically on every machine. Six locales have no hunspell dictionary at all
(fi ga lb mk mt rm); that is recorded as a known gap rather than silence, because
ga/mt/is-like locales are precisely where the garbled-word class concentrates.
WHAT WAS BUILT, MEASURED AND DELETED: a cross-locale outlier report, clustering
all 36 locales' values per key by shared character n-grams and flagging a locale
sharing nothing with the consensus. Recall 1 of 57, precision 1 of 65 — it found
Breaking change and nothing else, because app-specific terminology has no
cross-locale consensus to be an outlier against. Shipping a 1/65 tool into a
runbook the next pass trusts is worse than not having it, so it is not here. The
cross-locale check that does work is the one that already exists — `l10n-ai.js get
<key>`, used on demand once you have a suspicion, which is how Breaking change
(17 of 20 locales say "incompatible") and the swapped Uses/Used by pair were both
settled. Targeted beats scanned for that question.
Two bugs found while validating spell.js, both worth naming because both faked a
clean result:
· it suppressed unknown words hunspell had no suggestion for. That is exactly
backwards — a word so mangled the dictionary cannot propose a neighbour is the
MOST likely real defect, and is's Misheppnaðst and levranir are that shape.
· hunspell -l can name a SUB-token of a word (it splits on hyphens and
apostrophes), which was absent from the origin-key map and threw, killing the
report right after its header. A crash that prints a header and no findings is
indistinguishable from "nothing found", which is the worst failure available
to a reading aid.
All three reports exit 0 whatever they find, so none can gate a build or be
mistaken for one, and none of them writes: apply.js remains the only writer.
Runbook §6.9 now carries the three reports, their measured yields and the
fetchdicts prerequisite INLINE, and scripts/l10n/README.md lists the four scripts.
The method deliberately lives in the runbook rather than in a separate document, so
that a pass reading §6.9 gets it without a second lookup. The blind spots are
recorded in each script header: termdrift cannot see inflection-level or word-order
splits, and the Slovak dictionary rejects BOTH auditný and audítny, so the 35-key
adjective misspelling that dominated the sk pass was invisible to spell.js.
Verified: all three run clean on sk/cs/is; spell exits with guidance rather than a
stack trace for a locale with no dictionary; check:specs, test:l10n:parity and
format green; test:l10n unchanged at 17; selfcheck passes for all 16 recorded
locales; no l10n/*.js modified by this commit — lib.js is untouched, so no shared
behaviour can have shifted.
Carries the one-time machine setup for the spell pass, each check's measured yield against sk's 57 corrections, the blind spots, and the record of what was built and deleted (the cross-locale outlier scanner, at recall 1 of 57). §6.9 keeps its inline summary — a pass reading the runbook should not need a second lookup to know the order — and now also points here for the detail.
The sk audit was committed as complete at 57 corrections. A second pass over the
same bundle, run as a parallel fan-out on a fresh context rather than by
re-reading, found five more. Four are not marginal:
· "Array Object Configuration:" — "Konfigurácia objektu polia" used the
NOMINATIVE PLURAL of pole where the genitive singular poľa belongs, so it read
"configuration of the object of the fields". The bundle already declines this
noun correctly elsewhere (na úrovni poľa, vyprázdnenie poľa, and the real
nominative plural in fasetovateľné polia) — the form was available and simply
not used. This makes the first pass's claim of "zero wrong case in sk" wrong.
· "Draft denial" — a noun where the measured convention takes the infinitive.
It is the primary NcButton of DenialComposerDialog.vue, carrying the saving
spinner, and its own sibling button "Compose denial" was already the
infinitive Zostaviť zamietnutie.
· "Analyze existing properties for improvement opportunities" — item 5 of the
"Analysis steps:" list in ExploreSchema.vue, whose other five items are all
infinitives (Získať, Extrahovať, Zistiť, Identifikovať, Porovnať). This one
alone switched to formal 2pl.
· "Property name of inversed relation" — obrátenej RELÁCIE uses the bundle's
word for SESSION (Priemer vyhľadávaní/reláciu) to mean RELATION, which the
bundle otherwise renders vzťah without exception (Relations → Vzťahy). 4 to 1.
· "Control which object views…" — ovládať means to operate a device, not to
decide which items are selected. The softest of the five and flagged as such
in its record entry so it can be reverted cheaply.
Each was confirmed at its call site before being accepted.
THE LESSON IS ABOUT METHOD, NOT THIS LOCALE. A single sequential reader has a
recall ceiling that care does not remove, because what survives a first read is
exactly what a tired eye normalises — a plausible-looking case ending, one list
item out of six, a noun that could pass for a heading. The read-through should be
run as a fan-out over independent chunks with a central adjudicator, and a
completed audit must NOT be read as proof a locale is clean. Recorded in
locales/sk.json under auditSecondPassNote so the next pass inherits it.
Verified: selfcheck and runtime-check ALL PASS; parity and format green; sk.js
still 2058 lines; corrections now 62.
The guidance to "parallelise the read-through" was abstract in the speedup doc
("readers", "one reviewer") and ENTIRELY ABSENT from the runbook, which is the file
a pass actually reads. So the most useful process change was documented in a way
that no agent could act on. §6.9 now carries it as a numbered recipe naming the
Agent tool: slice into ~4 chunks, one subagent per chunk in a single message,
shared context, structured candidates, central adjudication.
WHY IT MATTERS MORE THAN SPEED: the sk audit was committed complete at 57
corrections, and a second pass over the same bundle in a fresh subagent context
found five more — a nominative plural for a genitive singular, a noun where the
button convention takes an infinitive, one formal-2pl item in a six-item list of
infinitives, and the bundle's word for SESSION used to mean RELATION. The first
pass had also claimed "zero wrong case in sk", which was false. sk is 62, not 57.
A single sequential reader has a recall ceiling that care does not remove, so a
completed audit must not be read as proof a locale is clean.
Two constraints recorded with it, both measured rather than assumed:
· CHEAP MODELS GENERATE, THEY DO NOT DECIDE. On the pre-audit sk bundle a
Haiku-class reader returned one real finding at MEDIUM confidence and two at
HIGH confidence that were both wrong — nemajú for the correct 3sg nemá after a
genitive-plural numeral, and the masculine-animate obnovení for the correct
inanimate obnovené. Applying either writes a NEW error into correct Slovak and
nothing in this repo could catch it. Its only correct finding was its least
confident, so its confidence field is not usable as a filter.
· SUBAGENTS NEED A READ BOUNDARY. A subagent touching the checkout gets
CLAUDE.md and this runbook auto-attached, and §6.9 now names sk's findings and
trap list outright. Harmless in a real pass, fatal to any attempt to MEASURE a
reader against an already-audited locale — point those at a scratchpad copy.
No code change; docs only.
The speedup doc had grown into a 230-line narrative and the §6.9 additions read as essays. Both are now terse rule lists — the speedup doc is 64 lines, and the §6.9 fan-out and core/call-site blocks lost roughly two thirds of their length. Every rule and every measured figure is kept; the surrounding prose is not. No behaviour change; docs only.
… spell.js Both found by running the audit reports against `ca`, the first locale whose orthography the spell report had not met. fetch-dicts: `ca fr sv lt be` all failed. LibreOffice does not lay its dictionaries out uniformly — `ca`, `fr_FR` and `sv_SE` keep theirs in a `dictionaries/` subdirectory, `lt_LT` uses the bare `lt` basename rather than `lt_LT`, and `be_BY` publishes only `be-official`. Five map entries corrected; all five now fetch. 28 of 36 locales have a dictionary, up from 23. spell.js: U+00B7 MIDDLE DOT is word-INTERNAL in Catalan and was missing from the token class, so every geminate-l word split into two junk halves — `col·lecció` became `col` + `lecció`, `paral·lelisme` became `paral` + `lelisme`, and `instal·lada` became `insta` + `lada`. Seven such halves were reported as misspellings. The `ca` report drops from 72 flagged words to 64, and none of the eight lost was a real word. Catalan is the only locale here that uses the interpunct, which is why five earlier passes never saw it. Neither script touches lib.js, so shared behaviour cannot have shifted and the all-locale regression loop does not apply.
Second Tier 2 locale, and the fourth audited overall. Whole bundle, 2052 values, 128 corrections (6.2%) — above cs (5.5%) and sk (3.0%), below is (22%). Method: the three reports first (core-diff, termdrift, spell), then an exact-value-collision scan, a dangling-preposition sweep and an elision sweep, then the whole listing read as a four-way subagent fan-out with every candidate adjudicated centrally against core and the call site. The fan-out produced 85 candidates and about 20 died in adjudication — the same ratio sk saw. TWO ON-SCREEN COLLISIONS, which is a defect class neither cs nor sk had: Settings/Configuration both rendered Configuració, and three dialogs use them as SIBLING TAB LABELS (EditConfiguration 33/128, EditWebhook 23/215, EditOrganisation 35/380) — two tabs with the same name. Core ca splits them (Paràmetres/Configuració) and so did the bundle's own one key containing both words. Escalated because it is a first-class entity noun over 30+ keys; the owner chose to normalise all 35. Configuració is now the Configuration entity and Paràmetres the Settings sense. Logs/Registers both rendered Registres, and ViewSource.vue builds its tab bar as tabs: ['Registers', 'Logs'] while both its empty states read the same. Core ships no Log key, so core could not decide it; 13 of 16 sibling locales distinguish the two and only the three Ibero-Romance ones collapse them — es and pt, both still un-audited, so not evidence. Registres is locked as the primary entity, so Logs took the qualifier its 16 sibling log keys already use. Other classes: 11 dangling prepositions in column headers (Detected At → Detectat a, and To Date → Fins a la data, which is the Catalan idiom for "up to now"); 5 RBAC permission-matrix headers written as imperatives instead of verbal nouns (§8.7, the same defect hr and lt had); 6 keys glossing "record" as registre and so colliding with Register; 4 token → testimoni (core-backed); 4 (s)-parentheticals expanding to non-words (dia(es) → "diaes"); 2 elision failures; 15 wrong senses including four false friends that read perfectly in isolation — inconsistent (= flimsy), citació (= summons), desplaçament (= scrolling), autoritzat (= authorised, not authoritative). CORE AND THE CALL SITE OVERTURNED THE REST, and two of them were collisions indistinguishable from the two real ones: Refresh/Update → Actualitza and Remove/Delete → the suprimir family are both core ca VERBATIM, so both stay. The call site killed Good/Fair/Poor and Successful/Failed as agreement failures (no feminine antecedent; rastre is masculine) — the same false positive sk produced — and Fonament and Punts finals died on the bundle's own vocabulary. All recorded in ca.json with the counts, including what was deliberately left. ca.json also gains spellAllow (43 domain words), so the next spell run over this locale is short. Verified: selfcheck ALL CHECKS PASS (128 audited corrections recorded), runtime-check ALL RUNTIME CHECKS PASS, check:specs, test:l10n:parity, format all green, gatetest confirms the gate holds ca, 2058 lines matching en.js, and selfcheck + detector controls + runtime-check re-run green across all 16 recorded locales. test:l10n stays RED at its pre-existing 17 keys (§10) — this pass touches no src/ and adds no key, so it cannot affect that count.
…fixes
Register FORMAL, 200 markers vs 9 over 3321 translated values. Buttons are
INFINITIVE, 64 vs 0 over 59 action keys. nplurals=2, plain `n != 1`, and
runtime-check confirms header and library agree at every count.
THIN CORE COVERAGE IS MORE DANGEROUS THAN NONE. rm and mt had zero lb
catalogues, so coreCatalogues() threw and §5 step 2 could not run by
accident. lb has exactly ONE catalogue with 72 values, so the call
SUCCEEDS — and those 72 values contain no address form at all, so the scan
would have reported a verdict computed from 0 markers of either polarity.
detectors/lb.js therefore counts core's markers rather than its catalogues,
prints "too thin to decide anything", and falls back to the app family's own
frontend bundles as the mt pass did (1054 own + 2386 sibling values).
openregister's own half carries 0 informal markers; all 4 informal values
live in launchpad and openconnector and are real slips there. bs, at 55
values, is the same trap.
fold() DOES NOT LOWERCASE — a first for this codebase, and the whole design
rather than an optimisation. Lowercase `dir` is the informal 2sg dative;
capitalised `Dir` is the polite 2pl nominative. Both are attested (1 and 82).
A case-folding detector merges all 83 and inverts the verdict. The residue is
recorded in UNDETECTABLE: a value opening with the informal dative takes a
sentence-initial capital and cannot be distinguished; all 11 such values in
the corpus are polite.
Two further exclusions, both measured rather than reasoned. The MODALS
syncretise 1sg/2sg/3sg, so `muss` and `weess` carry no address information —
all 15 bare `muss` in the corpus are 3sg — while the regular 2sg of the same
verbs (kanns, wëlls, sollst) does. That is a partial paradigm split by
LEXICAL class, a third way after bg's and is's conjugation-class splits. And
`-t` is both the 2pl and the 3sg ending, so `kënnt` ("you can" / "he comes")
and `braucht` are out; only 2pl forms whose 3sg differs are kept.
THE AUDIT: 94 corrections, and the overwhelming majority are ONE obligatory
orthographic rule. The Eifeler Regel deletes a word-final -n before any
consonant but n/d/t/z/h and keeps it otherwise. It fires several times per
sentence, no gate can see it, and this bundle broke it in BOTH directions.
It is the one mechanical morphology check that has ever paid off here,
because the trigger is deterministic rather than agreement-based; the method
is docs/l10n-workflow.md §8.11.
THE PER-LEMMA CHECK IS NECESSARY BUT NOT SUFFICIENT, and this is the lesson
worth keeping. Comparing each lemma only against itself excused every lemma
occurring in a single environment: `Lueden` appears only WITH the final -n
and `Deele` only WITHOUT it, so both read as internally consistent. 26 values
were left uncorrected on the strength of a "16:0, no counter-example" count
that was really one copy-pasted phrase repeated thirteen times. Aggregating
by WORD CLASS shows the family does both — 118 kept against 108 deleted —
with directly parallel pairs: Lueden vum / Deele vun, Späicheren
feelgeschloen / bäisetze wëllt, erstellen wann / zesummeféiere wann. A
uniform lemma is evidence of one decision, not of a rule. Run both cuts.
Corrected in this commit; 48 further values fixed on that basis.
TRUE RESIDUE: 2 values, both pre-existing, both a bare sinn/ginn infinitive
governed by a preceding modal ("muss aktivéiert sinn mat", "kënne
erëmgewonne ginn wann"), where reducing to si/gi collides with the pronouns
and the family offers no directly parallel example either way. §3.8 governs
those two.
Splitting at HEAD also caught 44 violations in the half written during this
pass — more own-drift than any previous locale produced. Two Germanisms of my
own were caught the same way (Vom -> Vum, and `zu` for `ze` before an
infinitive), and the auto-fixer's own bug (extern -> the non-word exter) is
why §8.11 names the -ern exemption class.
Both cheap audit reports were structurally blind to all of this: corediff had
only 4 shared keys, termdrift found almost nothing because a heavily
compounding language buries the stem inside Lëschtenusiicht and
Webhook-Liwwerung, and the spell report does not exist for lb. Where all
three come back thin, ask what rule the language has that they cannot check.
Capitalisation is a fifth §8.10 outcome: grammatically FORCED, since
Luxembourgish capitalises every noun. Measured anyway and unanimous; the
conditioned measurement changes nothing (39:1 title-cased, 172:2 prose). Two
false positives worth knowing: {register}/{schema} are placeholders, and
lowercase `filteren` is the verb.
46 cognates recorded, every one with its §3.3 distinct-value count. Two
looked like cognates and were FILLER — `GitHub Personal Access Token` and its
GitLab sibling, which 32 locales translate, the exact shape the cs pass
caught. Conversely `Mappings` was kept on openconnector's evidence, which
owns the concept and compounds it as Mapping-Detailer. `Driver` is flagged in
locales/lb.json as the weakest entry in the set. Lexicon settled against core
and recorded: Files -> Datei, the app family being 111:0 against core's
Fichieren.
All 15 §8.4 wrong-sense offenders verified at their call sites: Right is an
RBAC permission, People the PERSON entity type, View a row action, Search a
field label, Handler a person, Bucket a histogram bin, Subject the GDPR data
subject.
selfcheck ALL CHECKS PASS, runtime ALL RUNTIME CHECKS PASS, gatetest
confirms the parity gate genuinely holds lb, and all 17 recorded locales
re-verified with no regression. check:l10n is byte-identical to HEAD at 129
issues and test:l10n is still RED on the same 17 pre-existing keys — both
unrelated to this work (§10).
Also folds the orphaned docs/l10n-audit-speedup.md into runbook §6.9 and
deletes it; that change predates this pass and no references to it remained.
Sixth low-resource locale. 1053 -> 2052 keys, key-for-key identical to en.js.
MEASURED
- Register: FORMAL, the least ambiguous verdict in the set. Core 218 polite
markers to 1 (5 catalogues, 603 values); the four sibling frontends 556 to 2.
`ti` occurs ZERO times in 3980 values, and all three informal values in the
corpus live outside this bundle (one core/encryption, two openconnector — now
recorded as §11 reciprocal work).
- Buttons: a FIFTH §7.3 pattern and the first non-categorical one. 2sg
imperative for a label, 2pl once the string is a sentence, sliding with
length: 219:1 at <=14 chars, 32:42 at 40-79, 7:35 at 80+, crossover ~40.
`Select`/`Choose` prompts take 2pl at any length (67:26).
- Plurals: nplurals=2, plain `n != 1`; header and library agree at every count.
- `ju lutem` is register-bearing (83:0 against `të lutem`) — only the second
locale where the politeness formula pays, because Albanian's inflects for the
ADDRESSEE rather than the speaker.
DETECTOR — 86 controls, all passing
Four measured exclusions, two of them total: `-ni` is the 2pl ending AND the
definite singular of every masculine -n stem (~45 nouns in the corpus); `-sh` is
the 2sg subjunctive AND the ablative plural of every noun; bare `do` is 2sg AND
3sg of `dua` AND the future particle (101 occurrences of `do të` in third-person
prose); and the whole `-oj` class is a 2sg/3sg homograph with no conjugation
split to rescue it. `tij`/`tyre` excluded as third person.
The left guard carries a HYPHEN — new in this set — because Albanian attaches
the definite ending to acronyms after one (`UUID-je`, `Token-i`, `PHP-ja`), so
`(?<!\p{L})` matched an inflectional ending as the 2sg copula. The apostrophe is
deliberately unguarded: `t'ju` is formal, `s'ke` informal.
AUDIT — 160 corrections over 1018 pre-existing values (15.7%)
- 39 ORTH-VEKTOR: `vectoriz-` -> `vektoriz-`. Albanian `c` is /ts/, and the
bundle already wrote `vektoriale`/`vektorë` 15 times — one value carried both
spellings, which settles it.
- 36 BUTTON-2SG: 2pl imperatives on short labels, against the length gradient.
- 18 TERM-ENTRY: `hyrje` for *entry*, where core sq uses that word for ACCESS
and renders "directory entries" as `zëra`. termdrift reported the minority
side and the minority was right (§6.9).
- 12 COLLISION-LOG: `Logs` and `Registers` both rendered `Regjistra` and are
ADJACENT TABS in src/modals/source/ViewSource.vue:246. `ditar` takes the log
sense, as every finished locale distinguishes them.
- 3 COLLISION-PURGE: `Purge` collided with `Clear` on `Pastro` -> `Spastro`.
- plus 9 TYPO, 9 SENSE, 8 AGREEMENT, 6 AGREEMENT-PARTICIPLE, 6
LEFT-IN-ENGLISH, 4 TERM-DEFAULT, 4 ARTICLE, 3 NUMBER, 3
CONSISTENCY-PROGRESSIVE, 3 TERM-ENDPOINT, 2 TERM-FACET, 2 GARBLED, 1 each
TERM-ACCESS / TERM-PREVIEW / PERMISSION-NOUN / CONSISTENCY.
TOOLING
loadLocaleConfig now whitelists `spellAllow`, which spell.js already read but
never received — ca.json's 43 recorded words were being dropped and every run
printed "0 allowlisted". `spell ca` goes from 63 unknown words to 19, `sq` from
185 to 25 (the remainder are sub-token artefacts).
DOCS
§8.10 gains the finding most likely to transfer: a capitalisation ratio
conflates prose with Title-Cased headings, and the confound points toward doing
the work. The naive scan reported this bundle capitalising domain terms 25-35%
against a family rate near zero; conditioned on the English key it is 0 of 177,
and all 110 "defects" were headings correctly mirroring their source.
VERIFIED
selfcheck ALL PASS, runtime ALL PASS, detector 86/86, gatetest confirms the
parity gate genuinely fails and names sq. All 17 recorded locales re-checked
green after the lib.js change. check:specs PASS, test:l10n:parity OK with 33
finished locales, format clean. check:l10n unchanged from HEAD at 129 issues;
test:l10n still RED on the same 17 pre-existing keys (§10) — this diff touches
neither src/ nor en.js.
Takes mk from 1053 to 2052 keys, at full key-for-key parity with en.js, and
audits the whole pre-existing half.
Register: FORMAL. Core is usable here (24 catalogues, 3424 values) and gives
565 formal markers against 59; the bundle's own 1053 values give 31 against
zero, so core and the file agree and there was nothing to overrule. Split the
59 before reading it: 25 twoj* possessives, 14 ti/te/tebe pronouns, ~20 2sg
presents, concentrated in one catalogue (settings 34) and reading as app-store
blurbs. Macedonian's T-V distinction is live and ordinary, so this is the plain
cs-style measured choice with no structural story.
Buttons: the sq LENGTH GRADIENT, replicated, with the crossover in the same
place at ~40 characters. Core runs 128:1 for the bare 2sg imperative at <=14
chars and 6:12 the other way at 80+. Its Select/Choose and Enter/Type prompts
take the 2pl at any length as sq's do — but Search goes the other way and is
not close (core 61:1 for 2sg), so the override is lexically bounded rather than
"any prompt".
Plurals: pluralBoundary "library". The header is modular, the library drops the
n%100!=11 guard, so only 11 and 111 disagree — the mirror of is, and narrower.
Form 0 stays the plain counted singular because it is still reached correctly at
1, 21, 31. No productive counted form: the izbrojana forma in -a exists but core
writes the plain plural for the app's nouns, so bg's hazard does not transfer.
Detector: VI is the Macedonian acronym for AI and a homograph of the formal
dative clitic vi. Case is the only discriminator, so fold() consumes the
all-caps form before lowercasing — the lb dir/Dir problem from the other end.
The hyphen goes in the left guard only. 67/67 controls pass. Two useful
negatives: bare ti is usable, and bare te is usable where bg's is not.
Audit: 114 of 1053 pre-existing values corrected (10.8%), and 105 of those are
ONE mechanical rule. Macedonian sentence-cases common nouns in prose and in
headings; the family is unanimous (siblings 1:273, core 2:~480 in prose) and
the bundle ran 41:146 in prose and 65:507 in headings, all 41 prose hits inside
four terms while objekt — the app's most central noun — was 0:26. That
inconsistency is what makes it a defect rather than an sr-style convention.
The other 9: 4 agreement (prosecno + a plural noun in stat labels, resolved
with the bundle's own Maks./Min. abbreviation style), 3 progressive-form
outliers against a 20-value convention, 2 terminology (dnevnik -> log, akcija
-> dejstvo), and 1 Serbo-Croatian value. Zero garbled words, zero wrong plural
arrays, zero register deviations, right alphabet throughout.
Audit trail #{id} carried "Revizorski trag", Serbo-Croatian in both halves,
against 20 of this bundle's own values using "reviziska traga" — the openbuild
Croatian catalogue reaching a committed bundle for the second time, in the same
key it reached in sr.
Three measurement gaps met while measuring the casing, two of them new: a stem
alternation without the i flag hides the entire thing being measured; (?<=.)
does not exclude a LATER sentence's first word (3 hits, each of which would
have been "corrected" into an error); and an opening parenthesis, a leading
emoji and deliberate all-caps each license a capital (14 of 132 raw hits).
The lb question was asked and came out no: clitic doubling of definite objects
looks like the Eifeler Regel and is not, because the trigger is semantic and
the clitic's position depends on clause type. 0 of 5. Recorded so the next pass
does not rebuild it.
12 recorded cognates. Reachable/Edit labels/No label/No labels were replaced
after being written earlier in this same pass, so apply's suggestion to record
a corrections reason does not apply to them (workflow §6.3).
selfcheck ALL PASS, runtime ALL PASS, gatetest confirms the parity gate holds
mk, and all 19 recorded locales re-verified. check:l10n stays at its 129
baseline.
Fifteen locale passes appended a case study each to whatever section they touched; exactly one commit ever removed anything. The rules had come to carry 3-5x their own length in retrospective evidence for themselves. Cut, in order of size: - the per-locale LINGUISTIC reference — register evidence per locale, suffix traps and pronoun homographs per language. Already in docs/l10n-ui-translation.md, which this file's own header table names as its home. Replaced with the generalisable rule plus a pointer. - per-locale case studies through §6 and §8, down to the rule each taught. - §9.2's prose retelling of its own defect-rate table; the table stays. Kept deliberately: the plural-boundary table (§7.1), the wrong-sense harvest table (§8.4) and the casing-outcome table (§8.10) — dense, app-specific, not per-locale. Also the counter-examples in §6.5 and §8.2, because the doc's most-repeated lesson is "do not port an answer across locales", and a rule stripped of its counter-example reads as universal when it is conditional. Two mechanism changes, since the cut alone would only re-accrete: - the file declares a 1600-line ceiling, and §5 step 11 now says a pass earns room here by deleting, not appending. - CLAUDE.md referenced the doc as an @ import. That syntax can pull all ~1500 lines into context on every call, and every other reference in the repo uses a plain path. Now plain too. No content moved elsewhere. All 63 headings kept, so the §N.M cross-references in CLAUDE.md, scripts/l10n/README.md, docs/l10n-ui-translation.md and the locale JSONs still resolve; verified inbound and internal.
Brings l10n/be.js from 1053 to 2052 keys, key-for-key identical to en.js.
REGISTER: formal, and the first verdict resting on an asserted ABSENCE rather
than a ratio. detectors/be.js over core's 14 be catalogues (1873 values) counts
334 formal markers and ZERO informal; the bundle's own pre-existing half runs
156 to zero. Neither corpus contains a single ты / цябе / табе / тво- form.
BUTTONS: infinitive, register-neutral (the cs/lt/lv/sk/rm/is/lb group).
Resolving 44 bare action keys against core gives Захаваць / Выдаліць / Дадаць /
Скасаваць / Рэдагаваць — forty-odd infinitives and not one imperative. Sentence-
length prompts take the 2pl imperative, which is the ordinary formal shape.
The 2sg imperative IS counted, the minority outcome: §6.5 test 1 passes because
labels are infinitives, test 2 because the enumerated forms are unambiguous. The
catch is that Belarusian builds the 2pl imperative as the 2sg plus -це
(выберы → выберыце), so the trailing (?!\p{L}) guard is the only thing between
the polarities — the West Slavic hazard in a different branch, so it is not a
family property. 85/85 controls, covering the -це locative trap (фармаце,
праекце, тэксце, запыце — nouns, not 2pl verbs) and the -ш trap (ваш, больш,
менш, хэш, кэш), either of which would invert the verdict.
PLURALS: nplurals=3, and the header, boundaries and expression are byte-identical
to Russian's while form 1 still needs a different NOUN — Belarusian takes the
nominative plural after 2-4 where Russian takes the genitive singular (2 запісы,
not 2 записа), with the adjective and verb going plural alongside. Core be is
one-sided across all 30 of its arrays. Header and library agree at every count.
AUDIT of the pre-existing half: 41 defects in 1053 values (3.9%), in line with
sk (2.8%) and cs (5.5%). Two were RUSSIAN values committed in a Belarusian
bundle — Audit trail #{id} and NO ACTION. Belarusian has no и, щ or ъ, so one
grep finds that class exactly; the same grep established that openbuild's entire
be.json is a separate Russian translation (426 lines), which harvest.js's
byte-identity guard cannot see, so all eight of its candidates were rejected.
The rest: a Russian calque for "default" against the file's own прадвызначан-,
Cancel against core's Скасаваць in six catalogues, Share disagreeing with the
bundle's own noun Абагульванні, Fixed rendered as "corrected" in a retry-policy
list, Totals byte-identical to Results on one sidebar, four dangling
prepositions in <th> timestamps, and nine View X action buttons written as
verbal nouns against the measured infinitive convention — the tell being that
one NcActions menu carried Выдаліць and Прагляд падрабязнасцей side by side.
SANDHI (§8.11): the question came back YES and the bundle already obeyed it.
у after a consonant or pause, ў after a vowel — deterministic, several times per
sentence, invisible to every gate. HEAD half: 98 correct word-initial ў and 47
correct у, zero violations either way. The half written here: 169 and 58, also
zero. Casing is flat lowercase (0 capitalised against 458), unchanged when
conditioned on the English key's own casing. Ellipsis mirrors the source key.
Nine cognates recorded with justifications. Five values written during the pass
were corrected before commit and so carry no corrections entry: No label (facet
sense written for the file-tag call site), a capitalisation outlier, a wrong 2pl
imperative спашлецеся for спашліцеся, a term split пераазначэнне against the
file's own перавызначэнне, and two coinages replaced with the bundle's own
vocabulary.
selfcheck 16/16, runtime all-pass, gate negative test passes, check:specs and
format green, check:l10n unchanged at its 129 baseline. test:l10n stays RED for
the pre-existing reason in §10 — a source-side rename job, its own commit.
The FINISHED_DEFAULT line also carries 'bs', added concurrently in the same
working tree by the parallel Bosnian pass; it shares the one line with 'be' and
could not be staged apart from it.
…heck
Two gaps found while working bs, both in classes no gate can see.
casing.js — the §8.10 mid-sentence capitalisation measurement, which five
passes had done by hand and which decided a third of sr's values and the whole
dominant class of mk's. Encodes the three documented ways the hand measurement
misleads: a missing `i` flag hides the very occurrences being counted, `(?<=.)`
excludes the value's first word but not a later sentence's, and an opening
bracket / leading emoji / deliberate all-caps each license a capital. Conditions
on the English key so prose and Title-Cased headings are never pooled — the
distinction that made sq's ~110-value defect class evaporate to 0-of-177.
Prints the bundle against sibling-frontend and core baselines plus a per-term
up:down split, and --mine restricts it to what the working tree changed, which
is the split-at-HEAD check for a pass's own drift. Found one real defect that
way on bs, and reported its own false positive first: a one-letter word cannot
be classified as all-caps on its own, so every `O` inside an all-caps heading
scored as a mid-sentence capital until a run had to be open for it to count.
script-coverage.js — a homoglyph check, and it now runs for EVERY locale rather
than only the non-Latin ones. A Cyrillic о (U+043E) inside a Latin word renders
identically to a Latin o while breaking search, sorting and speech; the value is
not empty, not identical to English, not wrong-arity, and reads as finished work.
The existing two lists cannot see it because they ask whether the expected script
is PRESENT, and it is. All 30 Latin-script locales had no coverage of this at all.
It found one defect in bs (`proširenо`) and one in mk (`првa`, a Latin a inside a
Cyrillic word — the inverse direction).
Two iterations were needed and both are recorded in the file:
- A hyphen is a morpheme boundary and must break the run. Macedonian, Serbian,
Bosnian and Albanian all attach case endings to a Latin acronym across one
(API-клуч, webhook-a, UUID-je), which is correct morphology. Testing whole
words reported 105 hits on mk and 19 on uk, essentially all of it that
construction.
- mk writes `сè` with a Latin è and core mk does the same in 7 values with zero
of the Cyrillic U+0450, so those 29 hits are the prevailing convention, not
defects. Recorded in a new `homoglyphAllow` field rather than suppressed in
the script — a section that always shows 29 hits trains the reader to skip it.
Suppressing them is what exposed mk's one real defect underneath.
`homoglyphAllow` is whitelisted in loadLocaleConfig, the trap that silently
dropped pluralOrder and spellAllow before it, and verified observably: mk goes
29 -> 1 and bs stays at 1.
Regression-checked across all 21 recorded locales — selfcheck, detector controls
and runtime-check all pass, and the non-Latin locales come back 0 homoglyphs
except mk's recorded set.
Completes the last locale: all 36 are now at full key-for-key parity with en.js.
2052 keys, 21 recorded cognates, 0 absent, 0 empty, 0 bad arity. selfcheck 16/16,
runtime all-pass, detector 58/58 controls, and the parity gate negative-tested so
the claim that it holds bs is checked rather than assumed.
REGISTER: formal (Vi), 367 second-person plural markers against 1 singular over
3416 frontend values. Core could not decide it — Nextcloud ships ONE bs catalogue
whose 55 values yield 0 markers of EITHER polarity, which is the §2.3 thin-core
trap where the scan succeeds instead of throwing. The §6.4 fallback over this
bundle plus three sibling frontends settled it. The single informal hit in the
corpus is not in this app: it is openconnector's "Još nemaš posredovanih
vjerodajnica…", the same defect class the sq pass found in the same bundle (§11).
BUTTONS: bare 2sg imperative against formal prose (pattern 2). The lexical prompt
override is a THIRD distinct partition of the same verb set after sq's length
grading and mk's grouping — here the English verb decides and the line runs
between Select (2sg, 20 of 20, 14-45 chars) and Choose/Enter (2pl, 5 of 5 each,
15-128 chars). Length is not the variable.
BYTE-IDENTITY WITH A SIBLING LANGUAGE IS NOT EVIDENCE HERE, which is the finding
worth carrying. §2.3 predicted the openbuild Croatian catalogue would be found
inside this committed bundle as it was in sr and mk. It was not: for bs that
catalogue is filed under bs.json, the backend set, which §1 puts out of scope.
And BCS share too much for the test to mean anything — `Revizijski trag #{id}`
matches hr exactly and is correct Bosnian. What paid instead was measuring
standard-language lexicon per term: the bundle is genuinely Bosnian, ijekavian
like Croatian (Osvježi, Sljedeće) with an Eastern-leaning lexicon (Sačuvaj not
Spremi, Kreiraj not Stvori), and a sweep of the whole known bs/hr divergence set
found exactly two Croatianisms.
AUDIT of the 1019 pre-existing translated values, 26 corrections, all recorded
with class codes in locales/bs.json:
TERM-HR 10 pružatelj -> pružalac (7, Bosnian forms this agent-noun class in
-lac); predložak -> šablon (3). Both had this pass's own half on
the other side, so the bundle was split against itself in both.
CONSISTENCY 9 Izvor capitalisation (5), kôd circumflex (2), log/zapis, and
the ... vs … outlier
SENSE 4 Commit Message was "confirmation message" on a GitHub publish
form; Totals/Register Totals used iznos, a monetary amount, over
object counts; Top Deleters used brisač, a wiper
SWAP 2 Uses/Used by written the wrong way round — adjacent tab titles,
and nothing mechanical catches a converse pair reversed
GARBLED 1 a Cyrillic о inside "prošireno"
Three no-change decisions are recorded with their counts, because an unrecorded
"left alone" is indistinguishable from "never looked": the audit-trail term keeps
both its genitive and adjectival forms (stylistic variation, not drift), Settings
keeps Postavke against the lone core catalogue, and the -irati/-ovati verb split
is conventionalised per lemma with cross-app corroboration.
CAVEAT ON RECALL: §6.9 prescribes a subagent fan-out for the read and this pass
could not use one, so the read was sequential. On sk a second fan-out found 5
defects a sequential read had missed. Treat this bundle's pre-existing half as
audited once, not twice.
The docs also carry the concurrent be pass's edits, since both passes were in
flight in the same files.
test:l10n:parity now fails for any required locale missing a key, the same way it already did for empty values and wrong plural arity. There is no per-locale gated set and no env override for it. All 36 locales are at parity, so a per-locale exemption list has nothing left to express — and it is the knob someone reaches for to turn a red build green, which is the one move the gate exists to prevent. If an English string lands without translations, the failure is the missing translation: §6.15 has the procedure, and the failure output now points at it. Also drops the progress/backlog reporting branch, which could only ever have reported an empty set, and the `finished` flag on each failure entry. gate-negative-test.js asserted the old "(declared FINISHED)" wording, so it would have gone green on a gate that had stopped naming the broken locale at all. It now asserts the failure names the locale, which is the property that actually matters — a gate that fails without saying which of 36 bundles broke sends the reader through all of them. Re-verified on bs, be, mk and nl: two cognate-enforced, one from the pre-rule set, and it fails and names each. Cognate enforcement is untouched and still opt-in per locale on scripts/l10n/locales/<loc>.json, because 15 locales predate that rule and carry ~375 unreviewed identical values. Reviewing them is §9.2. Verified: parity green over both translation sets, all 36 locales; format and check:specs green; negative test green on four locales.
![github-advanced-security[bot]](https://avatars.githubusercontent.com/in/57789?s=60&v=4){kind=small}
| * @return {RegExp} Test against a bare filename. | ||
| */ | ||
| function localeFileRe(loc) { | ||
| return new RegExp(`^${loc}(_[A-Za-z]{2,3})?\\.json$`) |
| .replace(/`[^`]*`/g, ' ') | ||
| .replace(/https?:\/\/\S+/g, ' ') | ||
| .replace(/\b[\w.-]+\.(json|js|vue|ods|xlsx|php|md|ya?ml)\b/gi, ' ') | ||
| .replace(/\b[a-z_]+(?:_[a-z_]+)+\b/gi, ' ') // snake_case identifiers |
Contributor
Quality Report — ConductionNL/openregister @
|
| Check | PHP | Vue | Security | License | Tests |
|---|---|---|---|---|---|
| lint | ✅ | ||||
| phpcs | ✅ | ||||
| phpmd | ✅ | ||||
| psalm | ✅ | ||||
| phpstan | ✅ | ||||
| phpmetrics | ✅ | ||||
| eslint | ❌ | ||||
| stylelint | ✅ | ||||
| build | ✅ | ||||
| check-specs | ✅ | ||||
| test-l10n | ❌ | ||||
| test-l10n-parity | ✅ | ||||
| format | ✅ | ||||
| composer | ✅ | ✅ 175/175 | |||
| npm | ✅ | ✅ 528/528 | |||
| app:check-code | ⏭️ | ||||
| info.xml | ✅ | ||||
| REUSE | ❌ | ||||
| PHPUnit | ✅ | ||||
| Newman | ✅ | ||||
| Playwright | ✅ | ||||
| Hydra gates | ✅ |
Quality workflow — 2026-08-20 14:49 UTC
Download the full PDF report from the workflow artifacts.
§7.4 lumped the fourteen literal-`(s)` keys (`register(s)`, `configuration(s)`,
`{days} day(s) left`, …) in with the `{plural}` source hack and told a pass to
ignore both. They are unrelated: in `{plural}` the morphology is interpolated by
the call site, whereas `(s)` is ordinary translatable text inside the key, so a
locale may render it however it likes — including dropping the parenthetical —
and there is nothing to fix in `src/`.
Measured across all 36 bundles, three strategies are in use and all are correct:
own parenthetical (`mk`/`nb` 14 of 14, `da` 13, `sq` 12, `et`/`ro`/`uk` 11), no
parenthetical at all (`bs`/`hu`/`it`, 14 of 14), and keeping `(s)` where `-s` is
the native plural marker (`es` `pt` `fr` `ca` `rm`, plus Dutch `configuratie(s)`
and Latvian `konfigurācija(s)`).
So "the value contains `(s)`" is not an audit signal — it flags the whole
Romance group for writing correct Romance. Intra-locale inconsistency is the
signal that works, and needs no knowledge of the target morphology. It locates
two defects, both in Tier 1 locales and now cross-referenced from §9.2:
- `de` writes `Schema(s)`/`Schema(s) ausgewählt` beside its own
`Konfiguration(en)`, `Objekt(e)`, `Tag(e)`. German pluralises this
`Schemata`/`Schemen`, never `Schemas`.
- `nl` writes `schema(s) geselecteerd` beside `object(en)`, `dag(en)`. Dutch is
`schema's` or `schemata`.
`Dashboard(s)`/`Widget(s)` in `de`/`nl`/`lb`/`da` are not defects by contrast —
those languages keep `-s` on English loanwords. `lv` mixes `(s)`, `(i)`, `(ām)`
and `(us)` across eight keys and needs a case-by-case read.
Contributor
Quality Report — ConductionNL/openregister @
|
| Check | PHP | Vue | Security | License | Tests |
|---|---|---|---|---|---|
| lint | ✅ | ||||
| phpcs | ✅ | ||||
| phpmd | ✅ | ||||
| psalm | ✅ | ||||
| phpstan | ✅ | ||||
| phpmetrics | ✅ | ||||
| eslint | ❌ | ||||
| stylelint | ✅ | ||||
| build | ✅ | ||||
| check-specs | ✅ | ||||
| test-l10n | ❌ | ||||
| test-l10n-parity | ✅ | ||||
| format | ✅ | ||||
| composer | ✅ | ✅ 175/175 | |||
| npm | ✅ | ✅ 528/528 | |||
| app:check-code | ⏭️ | ||||
| info.xml | ✅ | ||||
| REUSE | ❌ | ||||
| PHPUnit | ✅ | ||||
| Newman | ✅ | ||||
| Playwright | ✅ | ||||
| Hydra gates | ✅ |
Quality workflow — 2026-08-20 15:29 UTC
Download the full PDF report from the workflow artifacts.
`Vue Quality (eslint)` was red with 5 errors (817 warnings are pre-existing and
untouched):
vue/attribute-hyphenation :model-value can't be hyphenated x2
@nextcloud/l10n-enforce-ellipsis "..." should be the "…" character x3
The two hyphenation errors are free — `:model-value` -> `:modelValue` in
EditConfiguration.vue and EditWebhook.vue.
The three ellipsis errors are not, and that is the whole story of this commit.
Why an ellipsis is a translation change
---------------------------------------
`t('openregister', 'Saving...')` -> `t('openregister', 'Saving…')` changes the
translation KEY. Do it naively and the string falls out of every catalogue at
once: `test:l10n` gains 2 missing keys, and `test:l10n:parity` — which IS in
this repo's `frontend-checks` — starts failing across all 36 locales.
But no translation work was actually needed. All 37 catalogues already carry
`"Creating..."` and `"Saving..."` with real, human translations. This is a key
RENAME, so each locale's own existing value is reused verbatim, with only the
trailing glyph normalised to match the source:
nl "Aanmaken…" "Opslaan…"
de "Wird erstellt…" "Wird gespeichert…"
fr "Création en cours…" "Enregistrement en cours…"
ru "Создание…" "Сохранение…"
Nothing here is invented or machine-translated. The values were read out of the
locale files themselves and written back through `scripts/l10n/apply.js`, this
repo's own gated writer, one locale at a time — so every one of its six refusal
gates (not-an-en-key, plural arity, value===key, whitespace, placeholder drift,
clobbering) ran on each patch. 36 applied, 0 refused.
`eslint --fix` was tried and reverted
-------------------------------------
It rewrote a large set of unrelated files and INTRODUCED new errors
(`defineOptions() cannot be used to declare props`, a batch of
`no-use-before-define`). Reverted `src/` wholesale and did the five by hand.
Worth recording so the next person does not reach for it: on this codebase
`--fix` makes the count go up.
What is deliberately NOT fixed here
-----------------------------------
`Frontend Check (test:l10n)` is still red on its original 17 keys, and this
commit leaves that number exactly where it found it:
before: FAIL — 17 translation key(s) used in source but MISSING
after: FAIL — 17 translation key(s) used in source but MISSING
The obvious move — `node tests/l10n/check-l10n.js --write` — was tried and
backed out. It closes `test:l10n` and immediately opens `test:l10n:parity`,
because those 17 English strings then exist in `en.js` and in none of the 36
locales. Both gates are in `frontend-checks`, so that trade is not a fix; it
swaps a red gate for a different red gate and breaks one that was passing.
Those 17 are genuinely new UI copy (AVG/GDPR Art 15/30 wording, flow-list
help text) and need real translations in 36 languages, through the runbook in
`docs/l10n-workflow.md` and the per-locale register verdicts in
`docs/l10n-ui-translation.md`. That is this branch's actual remaining work, and
fabricating 612 values to make a gate green is precisely what this programme's
`--strict-identical` audit exists to catch.
Verification
------------
npx eslint src 0 errors (was 5) / 817 pre-existing warnings
check-l10n-parity.js rc=0 — all 36 locales at key-for-key parity
check-l10n.js FAIL on 17 — identical to before this commit
(measured by stashing these changes and re-running)
Note `CodeQL` is also red on this PR; it is unrelated to l10n or eslint and is
not addressed here.
Contributor
Quality Report — ConductionNL/openregister @
|
| Check | PHP | Vue | Security | License | Tests |
|---|---|---|---|---|---|
| lint | ❌ | ||||
| phpcs | ❌ | ||||
| phpmd | ❌ | ||||
| psalm | ✅ | ||||
| phpstan | ✅ | ||||
| phpmetrics | ✅ | ||||
| eslint | ⏭️ | ||||
| stylelint | ⏭️ | ||||
| build | ⏭️ | ||||
| check-specs | ✅ | ||||
| test-l10n | ❌ | ||||
| test-l10n-parity | ✅ | ||||
| composer | ⏭️ | ⏭️ | |||
| npm | ✅ | ❌ | |||
| app:check-code | ⏭️ | ||||
| info.xml | ✅ | ||||
| REUSE | ⏭️ | ||||
| PHPUnit | ❌ | ||||
| Newman | ❌ | ||||
| Playwright | ❌ | ||||
| Hydra gates | ❌ |
Quality workflow — 2026-08-21 07:31 UTC
Download the full PDF report from the workflow artifacts.
Contributor
Quality Report — ConductionNL/openregister @
|
| Check | PHP | Vue | Security | License | Tests |
|---|---|---|---|---|---|
| lint | ✅ | ||||
| phpcs | ✅ | ||||
| phpmd | ✅ | ||||
| psalm | ✅ | ||||
| phpstan | ✅ | ||||
| phpmetrics | ✅ | ||||
| eslint | ❌ | ||||
| stylelint | ✅ | ||||
| build | ✅ | ||||
| check-specs | ✅ | ||||
| test-l10n | ❌ | ||||
| test-l10n-parity | ✅ | ||||
| format | ✅ | ||||
| composer | ✅ | ✅ 175/175 | |||
| npm | ✅ | ✅ 528/528 | |||
| app:check-code | ⏭️ | ||||
| info.xml | ✅ | ||||
| REUSE | ❌ | ||||
| PHPUnit | ✅ | ||||
| Newman | ✅ | ||||
| Playwright | ✅ | ||||
| Hydra gates | ✅ |
Quality workflow — 2026-08-21 07:54 UTC
Download the full PDF report from the workflow artifacts.
…tually pass
Clearing the 5 eslint errors in the previous commit did NOT turn the job green.
It still exited 2, on stderr rather than in the report:
There are suppressions left that do not occur anymore. To resolve this,
re-run the command with `--prune-suppressions`.
That is a separate non-zero condition from "errors found", and it is easy to
misread: stdout says `0 errors, 817 warnings` while the process exits 2.
Measured on both trees rather than assumed, because the obvious reading is that
my own fix orphaned the suppressions:
pre-fix exit 2 822 problems (5 errors, 817 warnings) + stale-suppressions
post-fix exit 2 817 problems (0 errors, 817 warnings) + stale-suppressions
Same message on both sides, so the staleness is pre-existing and independent of
the error fix. Confirmed by pruning each tree and diffing the result — one entry
moves, identically, in a file neither commit touches:
src/modals/settings/LLMConfigModal.vue
@nextcloud/l10n-enforce-ellipsis count 9 -> 4
Someone fixed 5 ellipsis violations there and did not re-run the prune. Nothing
else in the file moves: 222 files still listed, total suppressed 1250 -> 1245,
one line of diff.
With that pruned and the 5 errors gone, `npm run lint` — the exact command CI
runs — exits 0.
npm run lint exit 0 (was 2)
check-l10n-parity.js exit 0 (unchanged)
check-l10n.js FAIL on 17 (unchanged — see previous commit)
Contributor
Quality Report — ConductionNL/openregister @
|
| Check | PHP | Vue | Security | License | Tests |
|---|---|---|---|---|---|
| lint | ✅ | ||||
| phpcs | ✅ | ||||
| phpmd | ✅ | ||||
| psalm | ✅ | ||||
| phpstan | ✅ | ||||
| phpmetrics | ✅ | ||||
| eslint | ✅ | ||||
| stylelint | ✅ | ||||
| build | ✅ | ||||
| check-specs | ✅ | ||||
| test-l10n | ❌ | ||||
| test-l10n-parity | ✅ | ||||
| format | ✅ | ||||
| composer | ✅ | ✅ 175/175 | |||
| npm | ✅ | ✅ 528/528 | |||
| app:check-code | ⏭️ | ||||
| info.xml | ✅ | ||||
| REUSE | ❌ | ||||
| PHPUnit | ✅ | ||||
| Newman | ✅ | ||||
| Playwright | ✅ | ||||
| Hydra gates | ✅ |
Quality workflow — 2026-08-21 08:21 UTC
Download the full PDF report from the workflow artifacts.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
The l10n files have been through the wringer.
All 36 non-English locales now carry a real translation for every one of the
2052 keys in
en.js— key-for-key, no gaps, no English fallbacks hiding in thebundles. Along the way a lot of what was already in there turned out to be wrong
rather than missing: wrong-language values, terminology that drifted two ways in
one bundle, buttons written against the locale's own convention, plural arrays
copied between languages that don't share boundaries. Those got audited and fixed
per locale rather than just topped up.
The checks were auditing the wrong file
tests/l10n/check-l10n.jswas checking frontendt()literals againstl10n/en.json— the backend catalogue, read by PHPIL10N, which no frontendcode path ever loads. So it demanded bookkeeping in a file the browser never sees
while
l10n/en.js, the one it actually loads, went unaudited and drifted about700 keys behind
src/. Nothing caught it, because a missing key makesOC.L10Nfall back to the English source string, which renders correctly.The two sets are separate concerns with separate consumers, not two renderings of
one source, and the check now says so. The backend
.jsonset still has noscanner — it would need to walk
lib/for PHP$l->t(), notsrc/.Same file, second bug: an
n()call has two source strings but only one cataloguekey, and it is neither of them — it's the
_singular_::_plural_identifier.The gate required the bare singular, which renders correctly at count 1 and falls
back to English for every other count, so every "3 objects" in all 36 locales
rendered English while the gate stayed green.
Also in here
check-l10n-parity.jsused to holdonly a hand-maintained "finished" list to full parity, with an env override.
With nothing left in progress that list was just a knob for turning a red build
green, so it's gone: missing keys, empty values and wrong plural arity are fatal
for every locale. It covers both sets, keeping them apart where they differ —
plural arity is checked on the frontend set only, since
.jsonplurals use akeyed object shape.
scripts/l10n/— status, worklist,harvest, register detectors, apply-with-gates, selfcheck, runtime check, and the
reading aids (core diff, term drift, spell, script coverage, casing). Plus the
runbook in
docs/l10n-workflow.mdso the next person doesn't rebuild it.