w-web-perm 1.1.12 → 1.1.13

package/src/js/getDelRefCount.mjs

@@ -0,0 +1,138 @@
+import eachOwn from './eachOwn.mjs'
+import { countAndRefs, fmtWarn } from './getAuthWarn.mjs'
+import { planRefChanges } from './refCascade.mjs'
+
+
+//群組頁／權限頁按「刪除」前, 計算刪除對引用端的影響, 並產生確認框文字(規則帳本 R-PRINCIPLE-00 c、d、原則 6、適用表 n; ADR-036):
+//  n: 刪除後, 引用被刪名稱之引用端列(任何 mode、含停用項目)將於同一次寫入內被連帶清理(自其授權字串移除該引用), 其數量以 planRefChanges 之 nDelHolders 計(與伺服端同一純函數, R-REF-CASCADE-01);
+//  c: 其中以 AND 引用且刪除後該名稱完全消失者 → 引用被移除後其 AND 限制解除, 授權可能變多(run05 前為「AND 項變懸空、授權被收回」, 與連帶清理互斥, 已改);
+//  d: 引用的名稱有多筆同名(歷史同名)而只刪其一 → 取各候選之交集, 候選變少則交集變寬, 其授權可能變多(任何 mode; 該名稱仍有實體, 引用不清理, 不計入 n).
+//兩頁共用: 群組頁引用端為 users(欄位 cgrups)、權限頁引用端為 grups(欄位 cpemis). 純函數, 不依賴 Vue／DOM.
+
+
+//KIND_OF: 被刪者種類 → 被刪表與引用欄位('Grup' 群組頁、'Pemi' 權限頁)
+let KIND_OF = {
+    Grup: { keyTable: 'grups', field: 'cgrups' },
+    Pemi: { keyTable: 'pemis', field: 'cpemis' },
+}
+
+
+/**
+ * 計算刪除所選列對引用者授權的影響(其中 AND 與歷史同名兩項)
+ *
+ * 被刪名稱只取「基準(store 之已儲存列)中存在」之列的名稱: 尚未儲存的新增列(id 不在基準)刪除不影響他人;
+ * 以基準名稱為準(引用者所寫的是已儲存的名稱, 未儲存的改名不影響其引用). 「刪除後」以刪除後的剩餘列(含未儲存的新增與改名)判斷,
+ * 「刪除前」之同名筆數以基準列計.
+ *
+ * @param {Array} delIds 輸入被刪列的 id 陣列
+ * @param {Array} rowsBase 輸入基準列(store 之 grups 或 pemis)
+ * @param {Array} holders 輸入引用者列(store 之 users 或 grups)
+ * @param {String} field 輸入引用欄位名('cgrups' 或 'cpemis')
+ * @param {Array} rowsRemain 輸入刪除後剩餘之列(目前清單剔除被刪列)
+ * @returns {Object} 回傳 { n, nWiden }: n 為以 AND 引用且名稱完全消失之引用者數(其 AND 限制將隨引用被清理而解除), nWiden 為授權可能變多之引用者數(歷史同名只刪其一)
+ * @example
+ *
+ * let users = [{ cgrups: '{"G1":{"mode":"AND","isActive":"y"}}' }]
+ * console.log(getDelRefCount(['g1'], [{ id: 'g1', name: 'G1' }], users, 'cgrups', []))
+ * // => { n: 1, nWiden: 0 }
+ *
+ */
+function getDelRefCount(delIds, rowsBase, holders, field, rowsRemain) {
+    let setIds = new Set(Array.isArray(delIds) ? delIds : [])
+    let delNames = []
+    eachOwn(rowsBase, (r) => {
+        if (r !== null && typeof r === 'object' && setIds.has(r.id)) {
+            delNames.push(r.name === undefined ? '' : r.name)
+        }
+    })
+    if (delNames.length === 0) {
+        return { n: 0, nWiden: 0 }
+    }
+    let res = countAndRefs(holders, field, delNames, rowsRemain, rowsBase)
+    return { n: res.n, nWiden: res.nWiden }
+}
+
+
+/**
+ * 計算刪除所選列對引用端之完整影響: 將被連帶清理(移除引用)之引用端列數、其中以 AND 引用者、歷史同名致授權可能變多者
+ *
+ * nRefs 以 planRefChanges 計(只算本次刪除: rowsOld 為基準列、rowsNew 為基準列剔除被刪 id 之列, 不含其他未儲存之編輯; holdersOld 為引用端列),
+ * 即伺服端寫入時實際會被改寫之引用端列數(任何 mode、含停用項目); nAnd／nWiden 沿用 getDelRefCount.
+ * nAnd 以 nRefs 為上限(AND 引用者本即屬被清理者之子集; 若「目前清單之未儲存改名」使兩者判準不一致, 不使文案出現「其中 M 位」大於總數).
+ *
+ * @param {Array} delIds 輸入被刪列的 id 陣列
+ * @param {Array} rowsBase 輸入基準列(store 之 grups 或 pemis)
+ * @param {Array} holders 輸入引用端列(store 之 users 或 grups)
+ * @param {String} kind 輸入被刪者種類: 'Grup'(群組頁)或 'Pemi'(權限頁); 其他值回傳全 0
+ * @param {Array} rowsRemain 輸入刪除後剩餘之列(目前清單剔除被刪列)
+ * @returns {Object} 回傳 { nRefs, nAnd, nWiden }
+ * @example
+ *
+ * let users = [{ id: 'u1', cgrups: '{"G1":{"mode":"AND","isActive":"y"}}' }, { id: 'u2', cgrups: '{"G1":{"mode":"OR","isActive":"n"}}' }]
+ * console.log(getDelImpact(['g1'], [{ id: 'g1', name: 'G1' }], users, 'Grup', []))
+ * // => { nRefs: 2, nAnd: 1, nWiden: 0 }
+ *
+ */
+function getDelImpact(delIds, rowsBase, holders, kind, rowsRemain) {
+    let res = { nRefs: 0, nAnd: 0, nWiden: 0 }
+    if (!Object.prototype.hasOwnProperty.call(KIND_OF, kind)) {
+        return res
+    }
+    let ref = KIND_OF[kind]
+    let base = Array.isArray(rowsBase) ? rowsBase : []
+    let setIds = new Set(Array.isArray(delIds) ? delIds : [])
+    let rowsNew = base.filter((r) => !(r !== null && typeof r === 'object' && setIds.has(r.id)))
+    let plan = planRefChanges({
+        keyTable: ref.keyTable,
+        rowsOld: base,
+        rowsNew,
+        holdersOld: Array.isArray(holders) ? holders : [],
+    })
+    //名稱是否「仍有存續列」依伺服端之身分判準(refCascade.diffRefTargets): 只有「同 id 同名」之列算存續, 刪除後以同名新增之新 id 列或由他列改名而來者不繼承引用, 故不算(否則 nRefs 計其被清理而 nAnd 以為名稱仍在, 漏報 AND 限制解除)
+    let nameOf = (r) => (r.name === undefined ? '' : r.name)
+    let baseById = new Map()
+    base.forEach((r) => {
+        if (r !== null && typeof r === 'object' && typeof r.id === 'string') {
+            baseById.set(r.id, r)
+        }
+    })
+    let remainRetained = (Array.isArray(rowsRemain) ? rowsRemain : []).filter((r) => {
+        let b = (r !== null && typeof r === 'object') ? baseById.get(r.id) : undefined
+        return b !== undefined && nameOf(b) === nameOf(r)
+    })
+    let c = getDelRefCount(delIds, rowsBase, holders, ref.field, remainRetained)
+    res.nRefs = plan.nDelHolders
+    res.nAnd = Math.min(c.n, res.nRefs)
+    res.nWiden = c.nWiden
+    return res
+}
+
+
+/**
+ * 刪除確認框文字: 有引用端將被清理(nRefs)或授權可能變多(nWiden)任一大於 0 才有文字(單一框、單一問句); 皆為 0 回空字串(不彈框)
+ *
+ * 文案依 nRefs／nAnd／nWiden 組合選鍵(語系鍵尾碼 kind): 僅 nRefs → confirmDelRefs; nRefs＋nAnd → confirmDelRefsAnd; nRefs＋nWiden → confirmDelRefsDup;
+ * 三者皆有 → confirmDelRefsAndDup; 僅 nWiden → confirmDelDupRefs({n} 為 nWiden). nAnd 為 0 或 nRefs 為 0 時不提 AND(nAnd 以 nRefs 為上限).
+ *
+ * @param {Object} impact 輸入 getDelImpact 之結果 { nRefs, nAnd, nWiden }
+ * @param {Function} $t 輸入語系函數(key → 文字)
+ * @param {String} kind 輸入被刪者種類: 'Grup'(群組頁) 或 'Pemi'(權限頁), 組成語系鍵 confirmDelRefs／confirmDelRefsAnd／confirmDelRefsDup／confirmDelRefsAndDup／confirmDelDupRefs 之尾碼
+ * @returns {String} 回傳確認框文字, 無影響為空字串
+ */
+function getDelConfirmText(impact, $t, kind) {
+    let n = impact && impact.nRefs > 0 ? impact.nRefs : 0
+    let m = n > 0 && impact && impact.nAnd > 0 ? Math.min(impact.nAnd, n) : 0
+    let w = impact && impact.nWiden > 0 ? impact.nWiden : 0
+    if (n > 0) {
+        let key = `confirmDelRefs${m > 0 ? 'And' : ''}${w > 0 ? 'Dup' : ''}${kind}`
+        return fmtWarn($t(key), { n, m, w })
+    }
+    if (w > 0) {
+        return fmtWarn($t(`confirmDelDupRefs${kind}`), { n: w })
+    }
+    return ''
+}
+
+
+export { getDelRefCount, getDelImpact, getDelConfirmText }
+export default getDelRefCount

package/src/js/getEffMode.mjs

@@ -0,0 +1,20 @@
+/**
+ * 取得合併模式之有效值: 'OR' 為 'OR', 其餘(缺、非字串、'or'、'XOR' 等無法判讀者)一律視為 'AND'
+ *
+ * 規則帳本 R-AUTH-MERGE-00 第 5 條、R-PRINCIPLE-00 e: 無法判讀時取最嚴之解讀. 略過該項會使 AND 限制消失而放寬, 故改視為 AND(mergeRules 中為「限制項」:只當交集項、不單獨當基底,該層無合法 mode 之啟用項時全 n,否則唯一項成基底而比修正前多給).
+ * 伺服端 mergeRules(src/plugins/mShare.mjs)、編輯器解碼(cvKpToObj)、無損表示判定(getKpLossy)與頁面提示(getAuthWarn)共用, 單一擁有者.
+ *
+ * @param {*} m 輸入 mode
+ * @returns {String} 回傳 'OR' 或 'AND'
+ * @example
+ *
+ * console.log(getEffMode('OR'), getEffMode('AND'), getEffMode('or'), getEffMode(undefined))
+ * // => OR AND AND AND
+ *
+ */
+function getEffMode(m) {
+    return m === 'OR' ? 'OR' : 'AND'
+}
+
+
+export default getEffMode

package/src/js/getKpLossy.mjs

@@ -1,21 +1,28 @@
-import isestr from 'wsemi/src/isestr.mjs'
 import eachOwn from './eachOwn.mjs'
 import cvKpToArr from './cvKpToArr.mjs'
-import isAuthMode from './isAuthMode.mjs'
+import getEffMode from './getEffMode.mjs'
 
 
 /**
  * 判定帶 mode 之授權資料(JSON5.parse(cgrups／cpemis) 之結果)是否含「編輯器無法以物件形式無損表示」之格, 回傳受影響之名稱
  *
- * 編輯器存檔一律寫物件形式 { 名稱: { mode, isActive } }(每個名稱只有一個 mode、鍵序為 JS 屬性序); 外部應用可直接寫入陣列形式, 其下列兩格物件形式無法無損表示,
+ * 編輯器存檔一律寫物件形式 { 名稱: { mode, isActive } }(每個名稱只有一個 mode); 外部應用可直接寫入陣列形式, 其下列兩格物件形式無法無損表示,
  * 硬寫即靜默改變授權(規則帳本 R-AUTH-LOSSY-01; 複審 R4), 編輯器須拒存並顯示固定訊息(authLossyBlocked), 庫內字串不動:
- * 1. 同名有效啟用元素同時為 OR 與 AND: 物件形式只能留一個 mode. 保留 AND 支者, 另有其他 AND 名稱時 AND 合併之起始值由 OR 聯集改為第一個 AND 項而增權(外審 sol 第三輪#2);
- *    保留 OR 支或停用者亦會減權或增權, 一律視為有損(此格若整組只有該名稱則碰巧相等, 仍從嚴判定).
- * 2. 有效 AND 名稱 ≥ 2 且其相對順序於伺服端序(陣列元素首次有效出現之序)與物件鍵序(整數式鍵先、遞增)不同:
- *    mergeRules 在沒有有效 OR 項時以第一個 AND 項為 AND 合併之起始, 結果因之而異; 整數式名稱(如群組名 '1')在物件形式中恆排在前面, 陣列形式之順序無法保留.
- *    須比整個相對順序而非只比第一個: 查無實體(群組／權限表內沒有)之名稱會被伺服端 arrFinder 丟棄、編輯器存檔時亦不寫出, 丟棄後實際的第一個 AND 項可能是其後任一名稱(外審 sol#1／minimax#1).
- * 有效啟用元素: 名稱為非空字串、isActive 為 'y'、mode 為 OR／AND(同伺服端 arrFinder 以 === 比對名稱、mergeRules 跳過非 OR／AND 者).
- * 物件形式(編輯器自己寫出之形式、鍵唯一、鍵序即伺服端序)與其他輸入恆可無損表示, 回傳空陣列. 以原函式 getUserRules 為真理之窮舉驗證見 unit-cvKpToObj PR-001／PR-001b／PR-003
+ * - 同名啟用元素之有效模式同時為 OR 與 AND: 物件形式只能留一個 mode. 合併規則為「(所有 OR 聯集) ∩ (所有 AND)」(R-AUTH-MERGE-00), 同名同時為 OR 與 AND 時
+ *   該項既擴張聯集又收斂交集, 保留 AND 支會使聯集少了該項(減權), 保留 OR 支則少了一個交集條件(增權), 一律視為有損(此格若整組只有該名稱則碰巧相等, 仍從嚴判定).
+ * - 啟用元素之名稱不是字串(陣列元素無 name 等): 物件形式沒有對應的鍵. 該元素仍以懸空引用參與合併(內容全 n; AND 使結果為空, OR 使「無 OR 時以第一個 AND 為基底」失效,
+ *   R-PRINCIPLE-00 c), 靜默丟棄即放寬, 故拒存(R-PRINCIPLE-00 f 之「無法原樣保留則拒存」; 空字串名稱則可原樣保留為物件鍵 '', 不在此格). 名稱以 `#<序號>`(1 起算)表示.
+ *
+ * 不判定「該層啟用項皆 mode 缺或非法」(原第三格, ADR-035 決定 e; run06 使用者裁示放寬, ADR-035 Update 2026-10-22): mode 缺或非法之啟用項伺服端只當限制項
+ * (R-PRINCIPLE-00 e, 該層無任何 mode 合法之啟用項時結果全 n), 編輯器雖顯示為「AND、啟用」, 但存檔時對未被管理者改動者原樣寫回其原始 mode(editorRefRows 之
+ * getRawModeMap／putRowsToKp／putRefEntry, 方案 A; R-EDIT-KEEP-01), 故未改動時存檔前後授權相等、不會成為唯一 AND 基底而多給; 放寬前此格拒存只會使管理者無法存任何變更.
+ * 該項之 mode 缺漏提示仍由 getAuthWarn 之 modeInvalid 警告圖示承擔(不變). 管理者在對話框內明確改動(改為 OR／AND、啟用其他項)之結果, 等於伺服端對「改動後之狀態」之解讀,
+ * 未被改動之項不放寬(以真 getUserRules 窮舉證明見 unit-editorRows RT-LOSSY3-*).
+ *
+ * 不再判定「AND 名稱之相對順序」: 合併規則下結果與項目之儲存順序、物件鍵序、陣列元素序無關(R-AUTH-MERGE-00 第 4 條; ADR-033 取代 ADR-001 非對稱條),
+ * 整數式名稱被 JS 屬性序排前不再改變授權(原 run02 之排序保護 keepKeyOrder／getKeyOrderLost／getKpWriteLost 隨之移除).
+ * 啟用元素: isActive 為 'y' 者(mode 缺或非法者視為 AND 限制項, 見 getEffMode; 同伺服端 mergeRules).
+ * 編輯器自己寫出之物件形式(每個名稱有合法 mode)與其他輸入恆可無損表示, 回傳空陣列. 以原函式 getUserRules 為真理之窮舉驗證見 unit-cvKpToObj PR-001／PR-001b／PR-003
  * (凡存檔前後授權不相等者皆被本函數判定, 漏判 0; 本函數為保守側, 某些整體授權碰巧相等之格仍判有損).
  *
  * @param {Object|Array} kp 輸入 JSON5.parse(cgrups／cpemis) 之結果
@@ -24,64 +31,52 @@ import isAuthMode from './isAuthMode.mjs'
  *
  * console.log(getKpLossy([{ name: 'G1', mode: 'OR', isActive: 'y' }, { name: 'G1', mode: 'AND', isActive: 'y' }]))
  * // => ['G1']
+ * console.log(getKpLossy([{ name: 'G1', mode: 'OR', isActive: 'y' }, { name: 'G1', isActive: 'y' }]))
+ * // => ['G1']  (缺 mode 視為 AND)
+ * console.log(getKpLossy([{ mode: 'AND', isActive: 'y' }]))
+ * // => ['#1']
  * console.log(getKpLossy({ G1: { mode: 'OR', isActive: 'y' } }))
  * // => []
+ * console.log(getKpLossy({ G1: { isActive: 'y' } }))
+ * // => []  (該層啟用項皆 mode 缺漏: 原第三格, 已放寬)
  *
  */
 function getKpLossy(kp) {
-    if (!Array.isArray(kp)) {
+    if (kp === null || typeof kp !== 'object') {
         return []
     }
 
-    //seq: 有效啟用元素(依伺服端序)
-    let seq = []
+    //kpModes: 啟用元素之名稱 → 出現過的有效 mode; unnamed: 啟用而名稱非字串之元素
+    let kpModes = Object.create(null)
+    let unnamed = []
+    let k = 0
     eachOwn(cvKpToArr(kp), (r) => {
-        if (isestr(r.name) && r.isActive === 'y' && isAuthMode(r.mode)) {
-            seq.push({ name: r.name, mode: r.mode })
+        k++
+        if (r.isActive !== 'y') {
+            return true //跳出換下一個
         }
-    })
-
-    let out = []
-    let add = (n) => {
-        if (!out.includes(n)) {
-            out.push(n)
+        if (typeof r.name !== 'string') {
+            unnamed.push(`#${k}`)
+            return true //跳出換下一個
         }
-    }
-
-    //1) 同名同時有效 OR 與 AND
-    let kpModes = Object.create(null)
-    eachOwn(seq, (e) => {
-        if (!(e.name in kpModes)) {
-            kpModes[e.name] = []
+        let m = getEffMode(r.mode)
+        if (!(r.name in kpModes)) {
+            kpModes[r.name] = []
         }
-        if (!kpModes[e.name].includes(e.mode)) {
-            kpModes[e.name].push(e.mode)
+        if (!kpModes[r.name].includes(m)) {
+            kpModes[r.name].push(m)
         }
     })
+
+    //同名同時有效 OR 與 AND(僅陣列形式可能), 及啟用而無字串名稱者
+    let out = []
     eachOwn(kpModes, (ms, n) => {
         if (ms.length > 1) {
-            add(n)
-        }
-    })
-
-    //2) AND 名稱之相對順序於伺服端序與物件鍵序不同
-    let andOrder = []
-    eachOwn(seq, (e) => {
-        if (e.mode === 'AND' && !andOrder.includes(e.name)) {
-            andOrder.push(e.name)
+            out.push(n)
         }
     })
-    if (andOrder.length >= 2) {
-        let probe = Object.create(null)
-        eachOwn(andOrder, (n) => {
-            probe[n] = true
-        })
-        if (Object.keys(probe).some((n, i) => n !== andOrder[i])) {
-            eachOwn(andOrder, add)
-        }
-    }
 
-    return out
+    return [...out, ...unnamed]
 }
 
 

package/src/js/getNameErrs.mjs

@@ -0,0 +1,194 @@
+import eachOwn from './eachOwn.mjs'
+import findTouchedDup from './findTouchedDup.mjs'
+import getPropKey from './getPropKey.mjs'
+import { isExternalRow } from './externalRows.mjs'
+
+
+//後台清單頁(群組／權限／使用者)「名稱(或 email)擋存」之判準, 單一擁有者(規則帳本 R-PRINCIPLE-00 g、h, R-NAME-UNIQ-02):
+//  只擋「本次造成或觸及」者, 庫內既有的歷史問題(僅外部同步可造成)改為警告圖示而不擋存——否則已有歷史同名之庫在後台永遠存不了、無從修復.
+//  重複之判準與伺服端同一份(findTouchedDup, server/keyCheck.mjs 亦轉出之), 故「前端判擋存 ⇔ 伺服端回 nameDuplicate」.
+//  純函數, 不依賴 Vue／DOM／語系; 文字由呼叫端依 errBlock／warnHist／warnHistBad 之分類代入($t).
+//
+//  比對一律精確 ===; 以 Map 與無原型物件計, 免原型鍵名(constructor、__proto__)誤判(規則帳本 R-KEY-01).
+//  基準 rowsOld ＝ 最近一次由伺服端載入的列(store 之 grups／pemis／users 原始列); 新增但尚未儲存的列(id 不在基準內)視為本次造成.
+
+
+/**
+ * 取得清單頁某欄(name／email)之擋存錯誤與歷史警告
+ *
+ * 每一列之該欄值分三類:
+ *  - 壞值(empty): 不是字串或為空字串; 另 opt.isValid 給予時, 非空字串但不合格式者為 invalid(如 email 格式不符);
+ *  - 好值之重複: 好值在 rowsNew 內出現 ≥ 2 次; 用 findTouchedDup 判斷是「本次造成或觸及」(dup, 擋存)還是「歷史既有原樣」(warnHist, 不擋存);
+ *  - 其餘無事.
+ * 壞值預設一律擋存(opt.badScope 'all', 群組／權限之名稱: 伺服端 ckKey 對任一列之空／非字串名稱皆拒);
+ * opt.badScope 為 'touched' 時只擋「本次新增、或由其他值改成該壞值」之列, 基準內原樣就是壞值之列(歷史空值)不擋、改列入 warnHistBad(使用者之 name／email).
+ *
+ * 判定前先把兩邊列的有限數字 id 轉為字串(同伺服端), 非陣列視為空.
+ * 回傳之物件鍵為「儲存格之值」(非字串者依屬性鍵轉型, 空字串為 ''; 與清單頁以 props.value 查表一致), 皆為無原型物件.
+ *
+ * @param {Array} rowsNew 輸入目前清單之列(vo.opt.rows, 含未儲存之編修)
+ * @param {Array} rowsOld 輸入基準列(store 之原始列; 非陣列視為空)
+ * @param {String} [key='name'] 輸入欄位名
+ * @param {Object} [opt={}] 輸入設定物件
+ * @param {String} [opt.badScope='all'] 輸入壞值之擋存範圍, 'all' 或 'touched'
+ * @param {Function} [opt.isValid] 輸入好值格式檢查函數(值 → Boolean), 不給則任一非空字串皆合格
+ * @returns {Object} 回傳 { errBlock, warnHist, warnHistBad }:
+ *   errBlock     值 → 'empty' | 'invalid' | 'dup'(會擋存)
+ *   warnHist     值 → 目前共用該值之列數(歷史同名, 不擋存; 與 errBlock 互斥, 以擋存者為準)
+ *   warnHistBad  值 → 'empty' | 'invalid'(歷史壞值, 不擋存; 僅 badScope 為 'touched' 時有)
+ *   dupExternal  值 → 外部列之來源 from(僅 errBlock 為 'dup' 者, 且共用該值之列中有外部列〔from 為非空字串, externalRows.isExternalRow〕; 供提示改為「外部來源 X 已使用此名稱」, 否則無此鍵)
+ * @example
+ *
+ * let rowsOld = [{ id: '1', name: 'A' }, { id: '2', name: 'A' }]
+ * let r1 = getNameErrs(rowsOld, rowsOld, 'name')
+ * console.log(r1.errBlock.A, r1.warnHist.A)
+ * // => undefined 2
+ * let r2 = getNameErrs([...rowsOld, { id: '3', name: 'A' }], rowsOld, 'name')
+ * console.log(r2.errBlock.A, r2.warnHist.A)
+ * // => 'dup' undefined
+ *
+ */
+function getNameErrs(rowsNew0, rowsOld0, key = 'name', opt = {}) {
+    let o = (opt !== null && typeof opt === 'object') ? opt : {}
+    let touchedOnly = o.badScope === 'touched'
+    let isValid = typeof o.isValid === 'function' ? o.isValid : null
+
+    let errBlock = Object.create(null)
+    let warnHist = Object.create(null)
+    let warnHistBad = Object.create(null)
+    let dupExternal = Object.create(null)
+
+    let isRow = (r) => r !== null && typeof r === 'object'
+
+    //id 正規化: 有限數字 id 轉為字串(同伺服端 procCore.updateTabItems 於 findTouchedDup 之前所做, R-ORM-04), 其餘不變; 非陣列視為空.
+    //why: 前端若直接以數字 id 比對庫內之字串 id 會認不得同一列, 把歷史同名誤判為本次造成而擋存(兩端不一致)
+    let normIds = (rows) => {
+        if (!Array.isArray(rows)) {
+            return []
+        }
+        return rows.map((r) => {
+            return (isRow(r) && typeof r.id === 'number' && Number.isFinite(r.id)) ? { ...r, id: String(r.id) } : r
+        })
+    }
+    let rowsNew = normIds(rowsNew0)
+    let rowsOld = normIds(rowsOld0)
+
+    //基準: id → 基準列該欄之原始值
+    let kpOldVal = new Map()
+    eachOwn(rowsOld, (r) => {
+        if (isRow(r) && typeof r.id === 'string') {
+            kpOldVal.set(r.id, r[key])
+        }
+    })
+
+    //rowsNew: 壞值分類; 好值計次(Map: 值 → 列數)
+    let cnt = new Map()
+    eachOwn(rowsNew, (r) => {
+        if (!isRow(r)) {
+            return true //跳出換下一個
+        }
+        let raw = r[key]
+        let v = (raw === undefined) ? '' : raw //缺欄位視為空字串(同清單頁既有 get(v, 'name', ''))
+        let kind = null
+        if (typeof v !== 'string' || v.length === 0) {
+            kind = 'empty'
+        }
+        else if (isValid !== null && !isValid(v)) {
+            kind = 'invalid'
+        }
+        if (kind === null) {
+            cnt.set(v, (cnt.get(v) || 0) + 1)
+            return true //跳出換下一個
+        }
+        let kc = getPropKey(v) //儲存格值轉屬性鍵, 轉不了者(如 { toString: null })無從在畫面標示, 略過
+        if (kc === null) {
+            return true //跳出換下一個
+        }
+        //本次造成或觸及: 新列(id 不在基準)、或該欄值與基準不同
+        let touched = !(typeof r.id === 'string' && kpOldVal.has(r.id) && kpOldVal.get(r.id) === raw)
+        if (!touchedOnly || touched) {
+            errBlock[kc] = kind
+        }
+        else {
+            warnHistBad[kc] = kind
+        }
+    })
+
+    //好值之重複: 同值各列與基準中同值各列交給 findTouchedDup(兩端同一份判準)
+    let dupVals = []
+    cnt.forEach((n, v) => {
+        if (n >= 2) {
+            dupVals.push(v)
+        }
+    })
+    if (dupVals.length > 0) {
+        let setDup = new Set(dupVals)
+        let kpNew = new Map()
+        let kpOld = new Map()
+        eachOwn(rowsNew, (r) => {
+            if (isRow(r) && setDup.has(r[key])) {
+                if (!kpNew.has(r[key])) {
+                    kpNew.set(r[key], [])
+                }
+                kpNew.get(r[key]).push(r)
+            }
+        })
+        eachOwn(rowsOld, (r) => {
+            if (isRow(r) && setDup.has(r[key])) {
+                if (!kpOld.has(r[key])) {
+                    kpOld.set(r[key], [])
+                }
+                kpOld.get(r[key]).push(r)
+            }
+        })
+        eachOwn(dupVals, (v) => {
+            let kc = getPropKey(v)
+            if (kc === null) {
+                return true //跳出換下一個
+            }
+            let k = findTouchedDup(kpNew.get(v), kpOld.get(v) || [], key)
+            if (k >= 0) {
+                errBlock[kc] = 'dup'
+                let rExt = kpNew.get(v).find((r) => isExternalRow(r)) //另一方(或其中一方)為外部列: 提示改為「外部來源 X 已使用此名稱」
+                if (rExt !== undefined) {
+                    dupExternal[kc] = rExt.from
+                }
+            }
+            else {
+                warnHist[kc] = cnt.get(v)
+            }
+        })
+    }
+
+    //以擋存者為準
+    eachOwn(Object.keys(errBlock), (kc) => {
+        delete warnHist[kc]
+        delete warnHistBad[kc]
+    })
+
+    return {
+        errBlock,
+        warnHist,
+        warnHistBad,
+        dupExternal,
+    }
+}
+
+
+/**
+ * 把「值 → 分類(或筆數)」之無原型物件逐項轉為「值 → 文字」之無原型物件(清單頁以 props.value 查表), 供 computed 組 tooltip 文字用
+ *
+ * @param {Object} kp 輸入 getNameErrs 回傳之 errBlock／warnHist／warnHistBad
+ * @param {Function} fn 輸入轉換函數(分類或筆數, 值) → 文字
+ * @returns {Object} 回傳無原型物件
+ */
+function mapNameKp(kp, fn) {
+    let out = Object.create(null)
+    eachOwn(kp, (v, k) => {
+        out[k] = fn(v, k)
+    })
+    return out
+}
+
+
+export { getNameErrs, mapNameKp }

package/src/js/getOwn.mjs

@@ -1,5 +1,5 @@
 //授權與資料歸屬之查值: 供權限評估(src/plugins/mShare.mjs)、外部應用 SDK(src/perm.mjs)、後台整表寫入(server/procCore.mjs)與編輯對話框(VeCgrups／VeCpemis／VeCrules)共用
-//規則見 CLAUDE_rulebook.md「迭代使用端傳入之物件」之 R-AUTH-PATH-01
+//規則見 sgud/rule/rulebook.md「迭代使用端傳入之物件」之 R-AUTH-PATH-01
 //本檔無外部相依
 
 

package/src/js/getPropKey.mjs

@@ -0,0 +1,37 @@
+//資料驅動之名稱轉屬性鍵: 供權限評估(src/plugins/mShare.mjs mergeRules)與編輯對話框(經 cvKpToObj)共用
+//規則見 sgud/rule/rulebook.md「關聯對話框容錯、以身分配對、資料驅動屬性鍵」之 R-KEY-PROP-01
+//本檔無外部相依
+
+
+/**
+ * 把資料驅動之名稱轉為屬性鍵字串(與 `obj[name] = …` 之屬性鍵轉型相同), 轉不了者回 null
+ *
+ * 外部應用可直接寫入陣列形式授權資料([{ "name": …, "isActive": … }]), 元素 name 為任意 JSON 值; 以之當屬性鍵時,
+ * JS 先將物件轉為字串(ToPrimitive → toString／valueOf), 遇 `{ "toString": null }`、`[{ "toString": 1 }]` 等值必拋 TypeError
+ * (Cannot convert object to primitive value), 若不接住會使整個權限查詢失敗. 本函數與屬性鍵轉型取同一個 ToString:
+ * 可轉者回同一字串(5 → '5'、true → 'true'、null → 'null'、['T1'] → 'T1'、{} → '[object Object]'), 轉不了者回 null, 呼叫端略過該元素(不對應任何標的／規則, 等同不存在).
+ * 例外(Symbol, JSON 不會產生): 屬性鍵轉型可用(建立 symbol 鍵, 不被 Object.keys／eachOwn 走訪), 本函數回 null; 兩者效果相同(該元素不對應任何字串名稱之標的／規則).
+ *
+ * @param {*} name 輸入名稱(任意值)
+ * @returns {String|null} 回傳屬性鍵字串; 轉型會拋錯者回傳 null
+ * @example
+ *
+ * console.log(getPropKey('T1'))
+ * // => 'T1'
+ * console.log(getPropKey(5))
+ * // => '5'
+ * console.log(getPropKey({ toString: null }))
+ * // => null
+ *
+ */
+function getPropKey(name) {
+    try {
+        return `${name}`
+    }
+    catch (err) {
+        return null
+    }
+}
+
+
+export default getPropKey

package/src/js/isAuthMode.mjs

@@ -1,8 +1,8 @@
 /**
  * 判斷是否為合法合併模式 'OR' 或 'AND'
  *
- * 與伺服端 src/plugins/mShare.mjs 之 mergeRules 一致: mode 非 OR／AND 之群組／權限不納入合併(不授權).
- * 編輯器解碼(cvKpToObj)與無損表示判定(getKpLossy)共用, 單一擁有者.
+ * 用於偵測 mode 缺或不合法(頁面提示 getAuthWarn 之 modeInvalid). 伺服端 src/plugins/mShare.mjs 之 mergeRules 對 mode 非 OR／AND 之項
+ * 不再略過而是視為 AND 限制項(規則帳本 R-AUTH-MERGE-00 第 5 條、R-PRINCIPLE-00 e), 有效值見 getEffMode.
  *
  * @param {*} m 輸入 mode
  * @returns {Boolean} 回傳是否為 'OR' 或 'AND'

package/src/js/pairRowsToSnapshot.mjs

@@ -0,0 +1,84 @@
+//反向關聯對話框(VeGrupBlngUsers／VePemiBlngGrups)之「列 ↔ 資料快照」身分配對
+//規則見 sgud/rule/rulebook.md「關聯對話框容錯、以身分配對、資料驅動屬性鍵」之 R-REL-PAIR-01
+//本檔無外部相依
+
+
+//toId: 身分值正規化——非空字串，或有限數字(ADR-028: 數字主鍵以其字串形式處置)；其餘(空字串、NaN、物件、null、undefined)視為無身分
+function toId(v) {
+    if (typeof v === 'string' && v !== '') {
+        return v
+    }
+    if (typeof v === 'number' && Number.isFinite(v)) {
+        return String(v)
+    }
+    return null
+}
+
+
+/**
+ * 把對話框之列以「列身分」配對到存檔當下取得之資料快照(不用列索引)
+ *
+ * 反向關聯對話框(群組頁「所屬使用者」、權限頁「所屬群組」)開啟時依 store 當時的列序產生對話框的列; 存檔時重新取 store 快照.
+ * 兩者以列索引配對時, store 於開框期間被更新(另一位管理者增刪列或改 order)即錯位, 關聯寫到另一個使用者／群組(規則帳本 R-REL-PAIR-01).
+ * 本函數以身分欄位(預設 id)配對: 每列配到快照中身分相同(且 verifyKeys 欄位值全相等)的列; 配不到者列入 missing,
+ * 由呼叫端整次拒存並提示重新整理, 不得退而配到其他列.
+ *
+ * @param {Array} rows 輸入對話框之列, 每列帶身分欄位(opt.idKey); 非陣列時回傳空結果
+ * @param {Array} snapshot 輸入存檔當下取得之資料表快照(列物件陣列); 缺身分欄位之快照列不參與配對, 身分重複者取第一筆
+ * @param {Object} [opt={}] 輸入設定物件
+ * @param {String} [opt.idKey='id'] 輸入身分欄位名稱, 預設'id'
+ * @param {Array} [opt.verifyKeys=[]] 輸入除身分外另須與快照相等之欄位名稱陣列(如群組之 'name': 改名視為過期), 預設[]
+ * @returns {Object} 回傳 { pairs, missing, krs, matched }; pairs 與 rows 等長, pairs[kr] 為配到之快照列(同一個物件參考)，配不到為 null;
+ *   missing 為配不到之列(原物件)陣列; krs 為配得到之列的列索引(依列序), matched[i] 為 krs[i] 那一列配到之快照列(兩者等長、同序, 供「只處理配得到者」之顯示重算用, 免呼叫端自行壓縮索引)
+ * @example
+ *
+ * let snapshot = [{ id: 'u2', name: 'b' }, { id: 'u1', name: 'a' }]
+ * let rows = [{ id: 'u1', name: 'a' }, { id: 'u3', name: 'c' }]
+ * let { pairs, missing, krs } = pairRowsToSnapshot(rows, snapshot)
+ * console.log(pairs[0].name, pairs[1], missing.length, krs)
+ * // => 'a' null 1 [0]
+ *
+ */
+function pairRowsToSnapshot(rows, snapshot, opt = {}) {
+    let pairs = []
+    let missing = []
+    let krs = []
+    let matched = []
+    if (!Array.isArray(rows)) {
+        return { pairs, missing, krs, matched }
+    }
+    let idKey = (opt !== null && typeof opt === 'object' && typeof opt.idKey === 'string' && opt.idKey !== '') ? opt.idKey : 'id'
+    let verifyKeys = (opt !== null && typeof opt === 'object' && Array.isArray(opt.verifyKeys)) ? opt.verifyKeys : []
+
+    //kp: 身分 → 快照列(Map: 身分為 __proto__／constructor 等字串時亦精確)
+    let kp = new Map()
+    if (Array.isArray(snapshot)) {
+        for (let it of snapshot) {
+            let id = (it !== null && typeof it === 'object') ? toId(it[idKey]) : null
+            if (id !== null && !kp.has(id)) {
+                kp.set(id, it)
+            }
+        }
+    }
+
+    for (let kr = 0; kr < rows.length; kr++) { //索引迴圈(不用 forEach: 稀疏陣列之空洞須視為無身分列入 missing, pairs 與 rows 等長)
+        let r = rows[kr]
+        let id = (r !== null && typeof r === 'object') ? toId(r[idKey]) : null
+        let it = (id === null) ? undefined : kp.get(id)
+        if (it !== undefined && verifyKeys.every((k) => r[k] === it[k])) {
+            pairs.push(it)
+            krs.push(kr)
+            matched.push(it)
+        }
+        else {
+            pairs.push(null)
+            missing.push(r)
+        }
+    }
+
+    return { pairs, missing, krs, matched }
+}
+
+
+export { toId }
+export default pairRowsToSnapshot