@jeongpd/korean-kinship 0.1.1 → 0.1.2

package/README.md

@@ -165,8 +165,8 @@ Korean family-tree app, validated against actual usage. See
 - A dedicated sweep asserting no relation path ever resolves to an `undefined` or
   empty label, across every golden path plus a broad set of fallback-path
   combinations.
-- The compositional chon-cutoff rule independently re-verified against all 45
-  spouse-containing golden entries.
+- The compositional fallback's chon arithmetic (plain edge-sum, verified by hand
+  against a manual review) covering paths outside the golden table.
 
 CI (see badge above) runs this suite on every push, on Node 18 and 20 — the badge
 reflects the actual current state of `main`, not a claim in this README. Separately,
@@ -180,10 +180,13 @@ For the ~145 most common relationships, it is exactly a lookup table — that's
 and it's returned verbatim because it encodes real, occasionally non-obvious Korean
 usage conventions (for example: your sibling's spouse and your spouse's parents are
 conventionally given `chon: 0`, "just family," while your uncle's wife keeps your
-uncle's own `chon: 3` — these aren't derivable from one clean formula). For anything
-past that table, `resolve()` falls back to a compositional algorithm that computes
-촌수 and blood/in-law class from the path directly, so arbitrarily deep or unusual
-relationship chains still get a sensible answer instead of an error.
+uncle's own `chon: 3` — these aren't derivable from one clean formula, they're curated
+per entry). For anything past that table, `resolve()` falls back to a compositional
+algorithm that computes 촌수 as a plain edge sum and blood/in-law class from the path
+directly — it does not try to re-derive the golden table's "no number for close
+in-laws" convention (an earlier version tried, and silently mis-scored real 4th-degree
+relatives as chon 0), so arbitrarily deep or unusual relationship chains still get an
+arithmetically correct answer instead of an error or a guessed zero.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jeongpd/korean-kinship",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Resolve any Korean family-relationship path to its correct kinship term, reverse term, and 촌수 (degree of kinship) — including in-laws and 사돈.",
   "type": "module",
   "main": "./src/index.js",

package/src/resolve.js

@@ -24,9 +24,6 @@ function pickBySelfGender(record, selfGender) {
 export function walkPath(path) {
   let generationDelta = 0;
   let chonEdges = 0;
-  let bloodChonSoFar = 0;
-  let bloodChonAtFirstSpouse = null;
-  let firstSpouseIndex = null;
   let relationClass = 'blood';
   let olderYounger = null;
   // Gender of the person the path lands on. Every primitive but `spouse` fixes it
@@ -34,7 +31,7 @@ export function walkPath(path) {
   // hops has no gendered person to anchor on).
   let terminalGender = null;
 
-  for (const [index, id] of path.entries()) {
+  for (const id of path) {
     const rel = PRIMITIVES[id];
     generationDelta += rel.generationDelta;
     chonEdges += rel.edgeCost;
@@ -44,36 +41,29 @@ export function walkPath(path) {
     }
 
     if (rel.category === 'spouse') {
-      if (firstSpouseIndex === null) {
-        firstSpouseIndex = index;
-        bloodChonAtFirstSpouse = bloodChonSoFar;
-      }
       relationClass = 'inlaw';
       if (terminalGender !== null) {
         terminalGender = terminalGender === 'M' ? 'F' : 'M';
       }
     } else {
-      bloodChonSoFar += rel.edgeCost;
       terminalGender = rel.gender;
     }
   }
 
-  // In-law 촌수 is not the blood chon carried through. Korean puts no number on a
-  // relation once the chain crosses into another family: any hop *after* the first
-  // spouse hop (a second marriage link, or a blood hop taken from the spouse's own
-  // family — 사돈 territory) reports chon 0, as does a spouse hop onto a close blood
-  // relative (chon ≤ 2 at that point: self, child, sibling). Only a spouse hop onto a
-  // distant blood relative with nothing after it keeps that relative's own chon
-  // (큰아버지 3촌 → 큰어머니 3촌).
-  const hopsAfterFirstSpouse = firstSpouseIndex === null
-    ? 0
-    : path.length - 1 - firstSpouseIndex;
-
-  const chon = relationClass === 'inlaw'
-    ? ((hopsAfterFirstSpouse > 0 || bloodChonAtFirstSpouse <= 2) ? 0 : bloodChonAtFirstSpouse)
-    : chonEdges;
-
-  return { generationDelta, relationClass, olderYounger, chon, terminalGender };
+  // 촌수 here is always the plain edge sum — spouse hops cost nothing (부부는
+  // 무촌), so a spouse's blood relatives count from the spouse exactly as a
+  // careful speaker would by hand (배우자의 오빠의 딸의 딸 = 0+2+1+1 = 4촌).
+  //
+  // The golden table (Tier 1) separately encodes a real but *uncomputable*
+  // convention: Korean omits the number entirely for a specific, curated set of
+  // close relations (며느리, 처남, 사돈 — the golden entries with chon: 0). That
+  // convention does not generalize into a formula — an earlier version of this
+  // function tried to derive one ("zero any hop past the first spouse hop") and
+  // it silently mis-scored genuine 4th-degree relatives like the example above
+  // as chon 0. Since Tier 1 always resolves before walkPath() ever runs, this
+  // function doesn't need to reproduce that convention — it only has to be
+  // arithmetically correct for paths the golden table doesn't already cover.
+  return { generationDelta, relationClass, olderYounger, chon: chonEdges, terminalGender };
 }
 
 // The descriptor key deliberately omits 친가/외가/처가/시가 `side`. Detecting it