chaffjs 0.29.0 → 0.30.0

package/rules/party-order.yaml

@@ -0,0 +1,84 @@
+id: party-order
+layer: L3
+status: stable
+how_to_find: party-order
+word_list: party-order-joiner
+extra_word_lists: [party-order-label, party-short-name, party-role, company-form]
+requires: [structure]
+# An English contract has no fixed order for its parties: "the Supplier and the Customer" and "the Customer and the Supplier"
+# are both plain English. Japanese contracts list 甲 before 乙 by convention, so the rule is Japanese only.
+languages: [ja]
+severity: info
+
+name:
+  ja: 当事者の呼び名を、ほかの所と逆の順に並べている
+  en: Parties listed in the reverse of the document's usual order
+
+why:
+  ja: 契約書は当事者の呼び名を決まった順に並べます（甲及び乙、甲又は乙、甲乙、甲・乙・丙）。ほかの所で「甲及び乙」と書いた契約に「乙及び甲」が一つだけあると、読み手は順を変えた意味（乙を先に立てる理由）を探して止まります。条項を貼り合わせたときや、書き直したときに起きます。並べる語（及び・又は・と・・）でつないだ呼び名だけを数え、同じ二つの呼び名を逆の順に並べた所が、ふだんの順の半分以下のときに指します。
+  en: A Japanese contract lists its parties in a fixed order (甲及び乙, 甲又は乙, 甲乙, 甲・乙・丙). In a contract that writes 甲及び乙 everywhere else, a single 乙及び甲 makes the reader look for a reason to put 乙 first. It comes from pasted or rewritten clauses. Only names joined by a listing word (及び, 又は, と, ・) are counted, and a listing is reported when its order is written at most half as often as the reverse.
+
+message:
+  ja: 「{written}」は、この文書がほかの所で書く順（「{usual}」）と逆です
+  en: '"{written}" lists the parties in the reverse of the order this document uses elsewhere ("{usual}")'
+
+how_to_fix:
+  ja: ほかの所と同じ順に並べ替えてください。順に意味がある（乙を先に立てる）なら、そのままにします。
+  en: List the parties in the same order as elsewhere. If the order is meant (the second party first on purpose), leave it.
+
+levels: { strict: warning, normal: info, relaxed: info }
+
+use_for: [legal, docs, academic, literature, speech]
+off_for:
+  docs: "The order of a contract's parties is a contract's convention: the contract genre checks it."
+  academic: "The order of a contract's parties is a contract's convention: the contract genre checks it."
+  literature: "The order of a contract's parties is a contract's convention: the contract genre checks it."
+  speech: "The order of a contract's parties is a contract's convention: the contract genre checks it."
+  legal/statute: "A statute defines no parties: it names people by their role."
+  legal/judgment: "A court decision quotes each side's words in that side's order."
+  legal/patent: "A patent has no parties."
+
+group: consistency
+summary:
+  ja: 「甲及び乙」と書く契約の中の「乙及び甲」
+  en: 乙及び甲 in a contract that otherwise writes 甲及び乙
+example:
+  ja:
+    config: { genre: legal/contract }
+    before: |
+      # 業務委託契約書
+
+      株式会社みなと商会（以下「甲」という。）と株式会社しおさい技研（以下「乙」という。）は、次のとおり契約を結ぶ。
+
+      第1条　甲又は乙は、相手方が本契約に違反したときは、本契約を解除することができる。
+
+      第2条　本契約に定めのない事項は、乙及び甲が協議して定める。
+
+      第3条　本書2通を作成し、甲乙記名押印の上、各1通を保有する。
+    after: |
+      # 業務委託契約書
+
+      株式会社みなと商会（以下「甲」という。）と株式会社しおさい技研（以下「乙」という。）は、次のとおり契約を結ぶ。
+
+      第1条　甲又は乙は、相手方が本契約に違反したときは、本契約を解除することができる。
+
+      第2条　本契約に定めのない事項は、甲及び乙が協議して定める。
+
+      第3条　本書2通を作成し、甲乙記名押印の上、各1通を保有する。
+
+not_flagged:
+  ja: 向きのある言い方（乙から甲への通知、甲に対し乙は、甲が乙に）は、並べたのではなく順に意味があるので数えません。「、」は、あとに並べる語がある並び（甲、乙及び丙）だけをつなぎます。長い語の頭（甲種株式の甲、乙種の乙）は呼び名と読みません。二つの順の数が同じか近い（逆の順が半分より多い）ときは、どちらがふだんの順とも言えないので指しません。呼び名は甲・乙・丙・丁と、文書が括弧で当事者に定めた呼び名（以下「委託者」という）です。契約書のジャンルで、日本語の文書だけで動きます。
+  en: A direction (乙から甲への通知, 甲に対し乙は, 甲が乙に) is not a listing and is not counted. A comma joins names only in a listing that goes on to a listing word (甲、乙及び丙). A name that starts a longer word (the 甲 of 甲種株式) is not read. When the two orders are written about as often (the reverse more than half as often), neither is the usual order and nothing is reported. The names are 甲, 乙, 丙 and 丁 and the short names the document gives its parties in brackets. Contracts only, in Japanese documents only.
+rewrite:
+  depth: light
+  ja:
+    direction: 当事者の呼び名を、文書のほかの所と同じ順に並べ替えます。並べた語と、並べる語（及び・又は）は変えません。
+    pairs:
+      - before: 乙及び甲が協議して定める。
+        after: 甲及び乙が協議して定める。
+      - before: 乙又は甲は、本契約を解除することができる。
+        after: 甲又は乙は、本契約を解除することができる。
+    keep:
+      - 並べる語（及び・又は・と）
+    avoid:
+      - 向きのある言い方（乙から甲へ）の順を変える

package/rules/required-listed-as-preferred.yaml

@@ -0,0 +1,102 @@
+id: required-listed-as-preferred
+layer: L3
+status: stable
+how_to_find: requirement-lists
+# The headings and labels come from requirement-heading; a length of experience is read with requirement-length-unit,
+# requirement-length-word and number-word, and requirement-item-ending is taken off the end of an item.
+languages: [ja, en]
+severity: warning
+
+name:
+  ja: 必須の条件を歓迎の条件にも挙げている
+  en: A required skill listed again as preferred
+
+why:
+  ja: 求人の「必須」に挙げた資格や経験を「歓迎」にも挙げると、読み手はそれが必ず要るのか、あれば良いだけなのかが分からず、応募するかどうかを決められません。どちらかの項目を書き換えたつもりで、別の行を写したときに起きます。必須（必須スキル、応募資格）と歓迎（歓迎スキル、尚可）の見出しや札の下の箇条書きを比べ、同じ項目が両方にあれば、歓迎のほうを指します。大文字と小文字、全角と半角、記号、項目の終わりの「の方」「こと」は区別しません。経験の長さ（3年以上）は外して比べ、歓迎のほうが長い経験を求めていなければ同じ項目と読みます。
+  en: 'When a posting lists a qualification under "Required" and again under "Preferred", the reader cannot tell whether it is a must or only welcome, and cannot decide whether to apply. It happens when one line is copied in place of the one that was meant to be rewritten. The list items under a required heading or label (Required, Requirements, Must have) are compared with those under a preferred one (Preferred, Nice to have, Bonus points), and an item in both is pointed out where it is preferred. Case, full and half width and punctuation are ignored. A length of experience (3+ years) is taken out before comparing, and the two are read as the same item unless the preferred one asks for more experience.'
+
+message:
+  ja: 「{item}」は必須の条件（{required}）にも挙げています
+  en: '"{item}" is also listed as required ({required})'
+
+how_to_fix:
+  ja: 必ず要るなら歓迎から消し、あれば良いだけなら必須から消してください。歓迎で上の水準を求めるなら、「5年以上」のように違いを書いてください。
+  en: Remove it from the preferred list if it is a must, or from the required list if it is only welcome. If the preferred item asks for more, say how much more, such as "5+ years".
+
+# chaff explain と規則の一覧には指摘が無いので、{item} と {required} をこう読ませる。
+placeholders:
+  item:
+    ja: 〇〇
+    en: the item
+  required:
+    ja: 必須の項目
+    en: the required item
+
+levels: { strict: error, normal: warning, relaxed: info }
+
+use_for: [business, technical, blog, legal, docs, academic, literature, speech]
+off_for:
+  literature: "Length, rhythm, repetition and register are the author's choices in literature, and dialogue mixes styles. Only what one work can hold itself to runs: consistent spacing and commas, and numbering without gaps."
+
+group: structure
+summary:
+  ja: 求人で、必須に挙げた資格や経験を歓迎にも挙げている所
+  en: A skill or qualification in a job posting listed both as required and as preferred
+example:
+  ja:
+    before: |
+      # 求人：経理スタッフ
+
+      ## 必須
+
+      - 日商簿記2級以上
+      - 経理の実務経験3年以上
+
+      ## 歓迎
+
+      - 日商簿記2級以上
+      - 英語の書類を読めること
+    after: |
+      # 求人：経理スタッフ
+
+      ## 必須
+
+      - 日商簿記2級以上
+      - 経理の実務経験3年以上
+
+      ## 歓迎
+
+      - 連結決算の経験
+      - 英語の書類を読めること
+  en:
+    before: |
+      # Job posting: Accounts Assistant
+
+      ## Required
+
+      - A degree in accounting or finance
+      - At least three years of bookkeeping experience
+
+      ## Preferred
+
+      - At least three years of bookkeeping experience
+      - Reading business documents in Japanese
+    after: |
+      # Job posting: Accounts Assistant
+
+      ## Required
+
+      - A degree in accounting or finance
+      - At least three years of bookkeeping experience
+
+      ## Preferred
+
+      - Experience with consolidated accounts
+      - Reading business documents in Japanese
+
+not_flagged:
+  ja: 歓迎のほうが長い経験を求める項目（必須「Python」、歓迎「Python 5年以上」）は、上の水準を歓迎していると読んで指しません。違う言葉で同じことを言う項目（「簿記2級」と「日商簿記2級」）、資格の級の違い（「2級以上」と「1級」）、表に書いた条件、一つの行に「必須：Python、Go」のように並べた条件は比べません。見出しや札の無い箇条書きは読みません。
+  en: 'A preferred item asking for more experience (required "Python", preferred "5+ years of Python") is read as welcoming a higher level, and is not pointed out. Two items saying the same thing in other words ("bookkeeping" and "accounting"), different grades of a certificate, conditions written in a table, and conditions run together on one line ("Required: Python, Go") are not compared. A list without a required or preferred heading or label is not read.'
+level_meaning:
+  ja: 必須と歓迎の両方に同じ項目があるとき指摘
+  en: reported when the same item is listed as required and as preferred

package/rules/return-type-mismatch.yaml

@@ -0,0 +1,79 @@
+id: return-type-mismatch
+layer: L1
+status: stable
+how_to_find: return-type
+# The words come from the return-label (Returns, 戻り値), return-verb (returns, 返します), return-subject (は),
+# return-type-word (string, 文字列), return-clause (when, とき) and return-item (per, ごと) lexicons.
+requires: [markdown]
+severity: warning
+
+name:
+  ja: 戻り値の型が二通りに書かれている
+  en: A return type stated two ways
+
+why:
+  ja: API リファレンスで、関数のシグネチャと、「戻り値：」の行や表や文が違う型を返すと書いていると、読み手はどちらを信じてよいか分からず、返った値を間違った型として扱います。戻り値を変えたときに、片方だけを直すと起きます。コードブロックのシグネチャ（戻り値の型が付いたもの）を基準に、同じ見出しの下の「戻り値：」の行、戻り値の列を持つ表の行、関数名を主語にして「返します」と言う文を、同じ名前の関数どうしで比べます。Array<string> と string[] のような同じ型の別の書き方は同じと読み、「文字列」「数値」のような語は種類として比べます。
+  en: When an API reference's signature and a "Returns:" line, a table or a sentence say a function returns different types, the reader cannot tell which to trust and handles the value as the wrong type. It happens when a return type is changed in one place only. The signature in a code block (one with a return type) is the reference; a "Returns:" line under the same heading, a row of a table with a return column, and a sentence whose subject is the function's name and whose verb is "returns" are compared with it, for the same function only. Two spellings of one type (Array<string> and string[]) are the same, and words such as "string" or "number" are compared as kinds of value.
+
+message:
+  ja: 「{function}」の戻り値が「{stated}」と書かれていますが、シグネチャでは「{signature}」です
+  en: "`{function}` is said to return {stated} here, but its signature returns `{signature}`"
+
+how_to_fix:
+  ja: 実際の戻り値を確かめて、シグネチャか説明のどちらかを直してください。
+  en: Check what the function really returns, and correct the signature or the description.
+
+levels: { strict: error, normal: warning, relaxed: info }
+
+use_for: [technical, docs, blog, legal, academic, literature, speech]
+off_for:
+  legal: "Signatures and return types belong to technical writing."
+  academic: "Signatures and return types belong to technical writing."
+  literature: "Signatures and return types belong to technical writing."
+  speech: "Signatures and return types belong to technical writing."
+
+group: facts
+summary:
+  ja: API リファレンスで、シグネチャと説明が違う戻り値の型を言う所
+  en: A return type that the signature and the description state differently
+example:
+  ja:
+    config: { genre: technical/readme }
+    before: |
+      ## measure
+
+      ```ts
+      measure(text: string, tabSize = 4): number
+      ```
+
+      measure は、幅を "12" のような文字列で返します。
+    after: |
+      ## measure
+
+      ```ts
+      measure(text: string, tabSize = 4): number
+      ```
+
+      measure は、幅を桁数の数値で返します。
+  en:
+    config: { genre: technical/readme }
+    before: |
+      ## measure
+
+      ```ts
+      measure(text: string, tabSize = 4): number
+      ```
+
+      measure returns the width as a string such as "12".
+    after: |
+      ## measure
+
+      ```ts
+      measure(text: string, tabSize = 4): number
+      ```
+
+      measure returns the width as a number of columns.
+
+not_flagged:
+  ja: シグネチャの無い関数、別の名前の関数、引数の違う二つの宣言（オーバーロード。どちらかに合えば合っているとします）、型を読めないもの（オブジェクトの型、括弧で囲んだ型）、型の名前の無い文、二つの種類を言う文（文字列の配列）、条件の節の中の種類の語（「文字列が空のときに true を返します」の文字列）、一つ分を言う語が続く種類の語（「文字列ごとに」の文字列）、null だけを言う文（いつ null が返るかの説明）、ユニオンの一部だけを言うもの（number | null に対する number）、Promise やクラス名のように種類の語では比べられない型は見ません。「返していました」「返しません」のような過去や否定、関数名が主語でない文、名前と動詞の間に語を挟んだ英語の文（measure usually returns）、二つ以上の関数を宣言した見出しの下の「戻り値：」の行、コードブロックの中は読みません。
+  en: 'A function with no signature, a different function, two declarations with different parameters (overloads; a statement that fits either is fine), a type that cannot be read (an object type, a type in brackets), a sentence with no type in it, a sentence naming two kinds (an array of strings), a kind word inside a clause about when (string in "returns true when the string is empty"), a kind word naming one item ("one string per line"), a sentence naming only null (when null comes back), part of a union (number against number | null), and a type that a kind word cannot be compared with (Promise, a class name) are not reported. The past (returned), a sentence whose subject is not the function''s name or that puts a word between the name and returns (measure usually returns), a "Returns:" line under a heading that declares two or more functions, and code blocks are not read.'

package/rules/undefined-term.yaml

@@ -3,7 +3,7 @@ layer: L3
 status: stable
 how_to_find: undefined-term
 requires: [structure, pos]
-languages: [ja]
+languages: [ja, en]
 severity: info
 
 name:
@@ -11,8 +11,8 @@ name:
   en: A term written like a defined term but defined nowhere
 
 why:
-  ja: 契約や規約は、「本業務」「本サービス」のように、頭に「本」を付けた語を定義して使います。同じ形の「本成果物」を定義せずに書くと、読み手は、どこかで定義した語なのか、何を指すのかが分かりません。定義が抜けたのか、別の定義した語（本業務）を書き違えたのかのどちらかです。文書が「本」を付けた語を一つ以上定義しているときだけ、その形で書いたのに定義も言い換えの形（本件業務）も無い語を、最初の一か所だけ指します。
-  en: "A Japanese contract defines its terms with the prefix 本 (本業務, 本サービス). A term in the same form that is never defined (本成果物) leaves the reader asking whether it was defined somewhere and what it means: either a definition is missing, or another defined term was miswritten. Only a document that defines at least one term with that prefix is read, and only the first use of each such term with no definition and no other-prefix form (本件業務) is reported."
+  ja: 契約や規約は、「本業務」「本サービス」のように、頭に「本」を付けた語を定義して使います。同じ形の「本成果物」を定義せずに書くと、読み手は、どこかで定義した語なのか、何を指すのかが分かりません。定義が抜けたのか、別の定義した語（本業務）を書き違えたのかのどちらかです。文書が「本」を付けた語を一つ以上定義しているときだけ、その形で書いたのに定義も言い換えの形（本件業務）も無い語を、最初の一か所だけ指します。英語の契約は、定義した語を大文字で始めて書きます（the Services）。"X" means や (the "X") の形の定義が二つ以上ある文書で、文の途中に大文字で始めて書いたのに、どこにも定義が無い語（its Affiliates）も同じく指します。
+  en: "A Japanese contract defines its terms with the prefix 本 (本業務, 本サービス). A term in the same form that is never defined (本成果物) leaves the reader asking whether it was defined somewhere and what it means: either a definition is missing, or another defined term was miswritten. Only a document that defines at least one term with that prefix is read, and only the first use of each such term with no definition and no other-prefix form (本件業務) is reported. An English contract capitalises its defined terms (the Services); in a document with at least two definitions written with a defining word (“X” means, (the “X”)), a capitalised term inside a sentence that is defined nowhere (its Affiliates) is reported the same way."
 
 message:
   ja: 「{term}」は定義した語の形ですが、この文書のどこにも定義がありません
@@ -36,8 +36,8 @@ off_for:
 
 group: consistency
 summary:
-  ja: 「本業務」のように定義した語と同じ形の「本成果物」を、定義しないまま使っている所
-  en: A Japanese term in the defined form (本成果物) that the document never defines
+  ja: 「本業務」のように定義した語と同じ形の「本成果物」や、英語の契約で大文字で始めた語（its Affiliates）を、定義しないまま使っている所
+  en: A term in the defined form (本成果物, its Affiliates) that the document never defines
 example:
   ja:
     config: { genre: legal/contract }
@@ -53,10 +53,24 @@ example:
       第1条　甲は、ウェブサイトの保守の業務（以下「本業務」という。）を乙に委託する。
 
       第2条　乙は、本業務の報告書を甲に提出する。
+  en:
+    config: { genre: legal/contract }
+    before: |
+      # Services Agreement
+
+      This Services Agreement (this "Agreement") is made between Harbour Works Ltd (the "Supplier") and Northwind Retail Inc. (the "Customer").
+
+      1. The Supplier shall provide the hosting services (the "Services") to the Customer and its Affiliates.
+    after: |
+      # Services Agreement
+
+      This Services Agreement (this "Agreement") is made between Harbour Works Ltd (the "Supplier") and Northwind Retail Inc. (the "Customer").
+
+      1. The Supplier shall provide the hosting services (the "Services") to the Customer.
 
 not_flagged:
-  ja: 文書が「本」を付けた語を一つも定義していなければ見ません。定義した語とその言い換え（本件業務、defined-term-form が見ます）、定義した語で始まる語（本サービス上）、この文書やその一部を指す語（本条、本項、本書、本契約、本利用規約、本サイト）、どこかでかぎ括弧に入れた語（定義の書き方を chaff が読めなかったもの）、一語の言葉（本人、本日、本社）は見ません。同じ語は最初の一か所だけ指します。英語の文書は見ません（下の理由）。法令・判決・特許は見ません。契約書・規約のジャンルで見ます。
-  en: "A document that defines no term with the prefix is not read. Defined terms and their other-prefix forms (本件業務, which defined-term-form reads), terms that start with a defined term (本サービス上), the document's names for itself and its parts (本条, 本項, 本書, 本契約, 本利用規約, 本サイト), terms set in quotes anywhere (a definition chaff could not read), and single words (本人, 本日, 本社) are not reported. Each term is reported once, at its first use. English is not read: a capitalised word there cannot be told from the name of a law, an organisation or a policy (the Federal Trade Commission Act, Acceptable Use Policies) without its meaning. Statutes, court decisions and patents are not read; the contract genre runs this rule."
+  ja: 文書が「本」を付けた語を一つも定義していなければ見ません。定義した語とその言い換え（本件業務、defined-term-form が見ます）、定義した語で始まる語（本サービス上）、この文書やその一部を指す語（本条、本項、本書、本契約、本利用規約、本サイト）、どこかでかぎ括弧に入れた語（定義の書き方を chaff が読めなかったもの）、一語の言葉（本人、本日、本社）は見ません。同じ語は最初の一か所だけ指します。英語は、大文字は法令・組織・方針の名前（the Federal Trade Commission Act、Acceptable Use Policies）にも使うので、狭く読みます。"X" means や (the "X") の形の定義が二つ未満の文書は見ません。文の頭や記号の後ろの語、小文字の名詞の前に付けた語（the Premium plan）、名前の一覧（proper-name-word、地名、曜日と月、会社の形、当事者の役割）の語を含むもの、条の参照（Section 4、Schedule A）、見出し・リンク・太字・HTML の要素・表・箇条書きの見出しの中、どこかで引用符か太字に入れた語、定義した語を含むもの（大文字小文字を問いません）、文書のどこかで小文字でも書いた語（your Account と your account。普通の語か画面の名前）は見ません。法令・判決・特許は見ません。契約書・規約のジャンルで見ます。
+  en: "A document that defines no term with the prefix is not read. Defined terms and their other-prefix forms (本件業務, which defined-term-form reads), terms that start with a defined term (本サービス上), the document's names for itself and its parts (本条, 本項, 本書, 本契約, 本利用規約, 本サイト), terms set in quotes anywhere (a definition chaff could not read), and single words (本人, 本日, 本社) are not reported. Each term is reported once, at its first use. English is read narrowly, since capitals also name laws, organisations and policies (the Federal Trade Commission Act, Acceptable Use Policies): a document with fewer than two definitions written with a defining word (“X” means, (the “X”)) is not read; and a word at the start of a sentence or after a mark, a modifier of a lower-case noun (the Premium plan), a run holding a word of the name lists (proper-name-word, places, weekdays and months, company forms, party roles), a reference to a part (Section 4, Schedule A), anything inside a heading, a link, bold, an HTML element, a table or a list item's label, a word set in quotes or bold anywhere, a run holding a defined term in any case, and a word the document also writes in lower case (your Account and your account: an ordinary word or a screen's name) are not reported. Statutes, court decisions and patents are not read; the contract genre runs this rule."
 rewrite:
   depth: light
   ja:

package/src/derived/session-hours.ts

@@ -0,0 +1,62 @@
+import type { Span } from "../plugin.ts";
+import type { Mark } from "../structure/time-marks.ts";
+import { labelOf, readScopes, within, type TimeLength } from "./time-lengths.ts";
+
+/**
+ * A number of sessions times the length of one against the stated total (90分×15回（計24時間）, 15 sessions of 90
+ * minutes, 24 hours in total). Read in one line, or in a list whose items say it together, holding exactly one count of
+ * two or more sessions, one length of a session and one total. A total written as approximate (約24時間, about 24 hours)
+ * may differ by less than the smallest unit it is written in. Pure.
+ */
+export type Count = Span & { readonly amount: number };
+
+export type SessionHoursWords = { readonly totals: readonly Mark[]; readonly approximate: readonly Mark[] };
+
+export type SessionHoursMismatch = {
+  readonly count: Count;
+  readonly length: TimeLength;
+  readonly total: TimeLength;
+  /** The count times the length, in minutes. */
+  readonly expected: number;
+};
+
+const overlaps = (left: Span, right: Span): boolean => left.start < right.end && right.start < left.end;
+
+type Statement = { readonly count: Count; readonly length: TimeLength; readonly total: TimeLength };
+
+/** The length with a rough mark written before it taken in (計約24時間 reads its label past 約). */
+const withRoughMark = (text: string, length: TimeLength, words: SessionHoursWords): Span => {
+  const mark = labelOf(text, length, words.approximate);
+  return mark !== undefined && mark.end <= length.start ? { start: mark.start, end: length.end } : length;
+};
+
+const statementIn = (text: string, scope: Span, counts: readonly Count[], lengths: readonly TimeLength[], words: SessionHoursWords) => {
+  const inCounts = counts.filter((count) => count.amount > 1 && within(count, scope));
+  const inLengths = lengths.filter((length) => within(length, scope));
+  const totals = inLengths.filter((length) => labelOf(text, withRoughMark(text, length, words), words.totals) !== undefined);
+  const sessions = inLengths.filter((length) => !totals.includes(length));
+  const [count, length, total] = [inCounts[0], sessions[0], totals[0]];
+  if (inCounts.length !== 1 || sessions.length !== 1 || totals.length !== 1 || count === undefined || length === undefined || total === undefined)
+    return undefined;
+  if (overlaps(count, length) || labelOf(text, length, words.approximate) !== undefined) return undefined;
+  return { count, length, total } satisfies Statement;
+};
+
+const allowanceOf = (text: string, total: TimeLength, words: SessionHoursWords): number =>
+  labelOf(text, total, words.approximate) === undefined ? 0 : total.unit;
+
+/** Sessions whose count times length is not the stated total. counts are the written counts of sessions (15回, 15 sessions). */
+export const sessionHoursMismatches = (
+  text: string,
+  source: string,
+  sentences: readonly Span[],
+  counts: readonly Count[],
+  lengths: readonly TimeLength[],
+  words: SessionHoursWords,
+): SessionHoursMismatch[] =>
+  readScopes(text, source, { sentences, times: [] }, (scope) => statementIn(text, scope, counts, lengths, words)).flatMap(({ count, length, total }) => {
+    const expected = count.amount * length.minutes;
+    const allowance = allowanceOf(text, total, words);
+    if (allowance === 0 ? expected === total.minutes : Math.abs(expected - total.minutes) < allowance) return [];
+    return [{ count, length, total, expected }];
+  });

package/src/derived/time-lengths.ts

@@ -0,0 +1,226 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { isWordAt, wordOffsets, type Mark } from "../structure/time-marks.ts";
+import { linesOf } from "../structure/lines.ts";
+
+/**
+ * Lengths of time in hours and minutes (8時間, 7時間30分, 90分, 1-hour, one-hour, 7.5 hours), the words written beside
+ * them (実働8時間, 8 hours a day), and the stretches of text a statement of hours is read in. The words come from the
+ * language packages; nothing here knows a language. Pure.
+ */
+export type TimeLength = Span & {
+  readonly minutes: number;
+  /** The smallest unit the length is written in, in minutes: 60 for 24時間, 1 for 90分 or 7時間30分, 30 for 7時間半. */
+  readonly unit: number;
+};
+
+export type LengthWords = {
+  readonly hourUnits: readonly string[];
+  readonly minuteUnits: readonly string[];
+  /** What written right after the hour unit adds half an hour (7時間半). */
+  readonly halves: readonly string[];
+  /** Numbers written as words, in order from one. */
+  readonly numberWords: readonly string[];
+};
+
+const MINUTES_PER_HOUR = 60;
+const HALF_HOUR = 30;
+
+const alternation = (words: readonly string[]): string =>
+  words
+    .filter((word) => word !== "")
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+const LATIN_END = /[a-z]$/iu;
+const LATIN_START = /^[a-z]/iu;
+
+const numberOf = (written: string, numberWords: readonly string[]): number => {
+  const position = numberWords.findIndex((word) => word.toLowerCase() === written.toLowerCase());
+  return position >= 0 ? position + 1 : Number(written.normalize("NFKC"));
+};
+
+/** A digit number not inside a longer one, or a number word standing as a word of its own. */
+const numberPattern = (numberWords: readonly string[]): string => {
+  const words = alternation(numberWords);
+  const digits = "(?<![\\p{N}.,．/⁄])(\\p{Nd}+(?:[.．]\\p{Nd}+)?)";
+  return words === "" ? digits : `(?:${digits}|(?<![\\p{L}\\p{N}\\p{Pd}])(${words}))`;
+};
+
+const SEPARATOR = "[\\s\\-‐]?";
+
+type Read = { readonly span: Span; readonly minutes: number; readonly unit: number };
+
+/** A Latin unit runs on into a longer word ("8 hoursx") or a letter-led tail: not a length. */
+const runsOn = (text: string, end: number): boolean => LATIN_END.test(text.slice(end - 1, end)) && LATIN_START.test(text.charAt(end));
+
+const DECIMAL_BASE = 10;
+
+/** 7.5 hours is written to a tenth of an hour, 6 minutes. */
+const hourStep = (number: string | undefined): number => {
+  const decimals = (number ?? "").normalize("NFKC").split(".")[1]?.length ?? 0;
+  return MINUTES_PER_HOUR / DECIMAL_BASE ** decimals;
+};
+
+const smallestUnit = (number: string | undefined, minutes: string | undefined, half: string | undefined): number => {
+  if (minutes !== undefined) return 1;
+  return half === undefined ? hourStep(number) : Math.min(HALF_HOUR, hourStep(number));
+};
+
+const hourLengths = (text: string, words: LengthWords): Read[] => {
+  const [hours, minutes, halves] = [alternation(words.hourUnits), alternation(words.minuteUnits), alternation(words.halves)];
+  if (hours === "") return [];
+  const minutePart = minutes === "" ? "" : `|\\s?(\\p{Nd}{1,2})\\s?(?:${minutes})`;
+  const halfPart = halves === "" ? "" : `|\\s?(${halves})`;
+  const tail = minutePart === "" && halfPart === "" ? "" : `(?:${minutePart.slice(1)}${halfPart})?`;
+  const pattern = new RegExp(`${numberPattern(words.numberWords)}${SEPARATOR}(?:${hours})${tail}`, "giu");
+  return [...text.matchAll(pattern)].flatMap((match): Read[] => {
+    const end = match.index + match[0].length;
+    if (runsOn(text, end)) return [];
+    const amount = numberOf(match[1] ?? match[2] ?? "", words.numberWords);
+    const extra = match[3] === undefined ? 0 : Number(match[3].normalize("NFKC"));
+    const half = match[4] === undefined ? 0 : HALF_HOUR;
+    return [{ span: { start: match.index, end }, minutes: amount * MINUTES_PER_HOUR + extra + half, unit: smallestUnit(match[1], match[3], match[4]) }];
+  });
+};
+
+const minuteLengths = (text: string, words: LengthWords): Read[] => {
+  const minutes = alternation(words.minuteUnits);
+  if (minutes === "") return [];
+  const pattern = new RegExp(`${numberPattern(words.numberWords)}${SEPARATOR}(?:${minutes})`, "giu");
+  return [...text.matchAll(pattern)].flatMap((match): Read[] => {
+    const end = match.index + match[0].length;
+    return runsOn(text, end) ? [] : [{ span: { start: match.index, end }, minutes: numberOf(match[1] ?? match[2] ?? "", words.numberWords), unit: 1 }];
+  });
+};
+
+const overlaps = (left: Span, right: Span): boolean => left.start < right.end && right.start < left.end;
+
+/** Lengths of time in hours and minutes, in the order written. A minutes-only reading inside an hours one is dropped. */
+export const timeLengths = (text: string, words: LengthWords): TimeLength[] => {
+  const hours = hourLengths(text, words);
+  const minutes = minuteLengths(text, words).filter((read) => !hours.some((hour) => overlaps(hour.span, read.span)));
+  return [...hours, ...minutes]
+    .filter((read) => Number.isFinite(read.minutes) && read.minutes > 0)
+    .map((read) => ({ ...read.span, minutes: read.minutes, unit: read.unit }))
+    .toSorted((left, right) => left.start - right.start);
+};
+
+const longestFirst = (marks: readonly Mark[]): Mark[] => marks.toSorted((left, right) => right.pattern.length - left.pattern.length);
+
+const LABEL_GAP_BEFORE = new Set([" ", "\t", "\u3000", ":", "："]);
+const LABEL_GAP_AFTER = /^\s*/u;
+const LOOK_AROUND = 40;
+
+const lower = (text: string): string => text.toLowerCase();
+
+/** Where the separators that may stand between a label and its length (休憩：1時間、Break: 1 hour) begin, reading back from at. */
+const gapStart = (text: string, at: number): number => {
+  let start = at;
+  while (start > 0 && LABEL_GAP_BEFORE.has(text.charAt(start - 1))) start -= 1;
+  return start;
+};
+
+/** Whether pattern is written as a word at offset at, case aside. Reads a window around it, not the whole text. */
+const isLabelAt = (text: string, at: number, pattern: string): boolean => {
+  if (at < 0) return false;
+  const from = Math.max(0, at - 1);
+  return isWordAt(lower(text.slice(from, at + pattern.length + 1)), at - from, lower(pattern));
+};
+
+/** The label written right before span (after separators only), or undefined. */
+const labelBefore = (text: string, span: Span, marks: readonly Mark[]): Span | undefined => {
+  const end = gapStart(text, span.start);
+  if (span.start - end > LOOK_AROUND) return undefined;
+  const found = longestFirst(marks.filter((mark) => (mark.position ?? "before") === "before")).find((mark) =>
+    isLabelAt(text, end - mark.pattern.length, mark.pattern),
+  );
+  return found === undefined ? undefined : { start: end - found.pattern.length, end };
+};
+
+/** The label written right after span (after white space only), or undefined. */
+const labelAfter = (text: string, span: Span, marks: readonly Mark[]): Span | undefined => {
+  const start = span.end + (LABEL_GAP_AFTER.exec(text.slice(span.end, span.end + LOOK_AROUND))?.[0].length ?? 0);
+  const found = longestFirst(marks.filter((mark) => mark.position === "after")).find((mark) => isLabelAt(text, start, mark.pattern));
+  return found === undefined ? undefined : { start, end: start + found.pattern.length };
+};
+
+/** The label beside span, before or after it. */
+export const labelOf = (text: string, span: Span, marks: readonly Mark[]): Span | undefined => labelBefore(text, span, marks) ?? labelAfter(text, span, marks);
+
+/** Where the words of marks are written inside scope. */
+export const mentionsIn = (text: string, scope: Span, marks: readonly Mark[]): Span[] => {
+  const inside = lower(text.slice(scope.start, scope.end));
+  return [...new Set(marks.map((mark) => lower(mark.pattern)))].flatMap((pattern) =>
+    wordOffsets(inside, pattern).map((at) => ({ start: scope.start + at, end: scope.start + at + pattern.length })),
+  );
+};
+
+export const within = (inner: Span, outer: Span): boolean => inner.start >= outer.start && inner.end <= outer.end;
+
+const LIST_ITEM = /^\s*(?:[-*+・•]|\d{1,3}[.)])\s/u;
+
+type Paragraph = { readonly span: Span; readonly lines: readonly Span[]; readonly listed: boolean };
+
+type Run = { readonly lines: Span[]; listed: boolean };
+
+/** Runs of non-blank lines. listed: every line of the run is a list item in the source. */
+const paragraphsOf = (text: string, source: string): Paragraph[] => {
+  const listedLines = linesOf(source).map((line) => LIST_ITEM.test(line.text));
+  const runs: Run[] = [{ lines: [], listed: true }];
+  linesOf(text).forEach((line, index) => {
+    const run = runs[runs.length - 1];
+    if (line.text.trim() === "") runs.push({ lines: [], listed: true });
+    else if (run !== undefined) {
+      run.lines.push({ start: line.start, end: line.start + line.text.length });
+      run.listed = run.listed && listedLines[index] === true;
+    }
+  });
+  return runs.flatMap(({ lines, listed }) => {
+    const [first, last] = [lines[0], lines[lines.length - 1]];
+    return first === undefined || last === undefined ? [] : [{ span: { start: first.start, end: last.end }, lines, listed }];
+  });
+};
+
+const clipped = (inner: Span, outer: Span): Span => ({ start: Math.max(inner.start, outer.start), end: Math.min(inner.end, outer.end) });
+
+/** A sentence that ends on a clock time ("5:30 p.m. (a one-hour break") runs on into the next. */
+const joinedAtTimes = (sentences: readonly Span[], times: readonly Span[]): Span[] =>
+  sentences.reduce<Span[]>((joined, sentence) => {
+    const last = joined[joined.length - 1];
+    if (last !== undefined && times.some((time) => time.start < last.end && last.end <= time.end)) {
+      joined[joined.length - 1] = { start: last.start, end: sentence.end };
+    } else joined.push(sentence);
+    return joined;
+  }, []);
+
+/** The sentences of a line, clipped to it; the line itself when no sentence lies on it. */
+const sentencesOn = (line: Span, sentences: readonly Span[]): Span[] => {
+  const on = sentences.filter((sentence) => overlaps(sentence, line)).map((sentence) => clipped(sentence, line));
+  return on.length === 0 ? [line] : on;
+};
+
+/**
+ * The stretches a statement is read in: each sentence of a line, and a list whose items say it together (勤務時間 /
+ * 休憩 / 実働 on three items). read returns undefined when a stretch does not hold exactly one statement; a list that
+ * reads as one is not read again line by line.
+ */
+export const readScopes = <T>(
+  text: string,
+  source: string,
+  split: { readonly sentences: readonly Span[]; readonly times: readonly Span[] },
+  read: (scope: Span) => T | undefined,
+): T[] => {
+  const sentences = joinedAtTimes(split.sentences, split.times);
+  return paragraphsOf(text, source).flatMap((paragraph) => {
+    const whole = paragraph.listed && paragraph.lines.length > 1 ? read(paragraph.span) : undefined;
+    if (whole !== undefined) return [whole];
+    return paragraph.lines.flatMap((line) =>
+      sentencesOn(line, sentences).flatMap((scope) => {
+        const result = read(scope);
+        return result === undefined ? [] : [result];
+      }),
+    );
+  });
+};

package/src/derived/unit-counts.ts

@@ -0,0 +1,18 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+export type UnitCount = Span & { readonly amount: number };
+
+const LATIN_UNIT = /^[a-z]+$/iu;
+
+/** 数字と単位（3泊、3 nights、15回）。英字の単位は語の切れ目まで。Pure. */
+export const numeralCounts = (text: string, units: readonly string[]): UnitCount[] =>
+  units.flatMap((unit) => {
+    const tail = LATIN_UNIT.test(unit) ? "(?![\\p{L}\\p{N}])" : "";
+    const pattern = new RegExp(`(?<![\\p{N}.,])(\\p{Nd}+)\\s?${escapeRegExp(unit)}${tail}`, "giu");
+    return [...text.matchAll(pattern)].map((match) => ({
+      start: match.index,
+      end: match.index + match[0].length,
+      amount: Number((match[1] ?? "").normalize("NFKC")),
+    }));
+  });