@qe-libs/rena-wasm 0.1.2 → 0.1.5

package/README.md

@@ -34,8 +34,8 @@ const model = ena.fit(rows, {
 
 model.model.centroids  // Float64Array  nUnits × dims
 model.lineWeights      // Float64Array  nUnits × nConnections (normed)
-model.connectionCounts // Float64Array  nUnits × nConnections (raw unit counts)
-model.rowConnectionCounts // Float64Array nRows × nConnections (raw row counts)
+model.connectionCounts // Float64Array  nUnits × nConnections (unit counts, before normalisation)
+model.rowConnectionCounts // Float64Array nRows × nConnections (each row's counts after binarize / weight; rows sum to connectionCounts)
 model.rotation.nodes   // Float64Array  nCodes × dims
 model.connectionNames  // ['Data & Technical.Constraints', ...]
 model.model.unitLabels // ['UserName1_ConditionA', ...]
@@ -67,6 +67,30 @@ const model = ena.fit(rows, {
 
 ---
 
+## Weight Models
+
+`weightModel` (= R's `weight.by` / tma's `weight_by`) is applied to each line's
+co-occurrence counts **before** they are summed into the unit network, by
+libqe's shared `finalize_row_connections` kernel — the same stage and results
+as rENA's `ena.accumulate.data()` and `tma::accumulate()`.
+
+| `weightModel` | Per line |
+|---|---|
+| — (default) | binary: each positive count becomes 1 (`binary: false` keeps raw counts) |
+| `'product'` | the raw, non-binarized counts |
+| `'sqrt'` | square root of each line's count |
+| `'log'` (alias `'log1p'`) | `log(1 + x)` of each line's count |
+
+For ordered (directed) networks the weight is applied to each directed cell,
+and the default keeps the raw directed counts. `weightModel` works in `fit()`,
+`accumulate()` and `tuneWindowSize()`.
+
+```js
+const model = ena.fit(rows, { codes, units, conversations, window: 4, weightModel: 'sqrt' });
+```
+
+---
+
 ## Accumulation Only
 
 Returns raw (un-normalised) network vectors without running the full pipeline.
@@ -92,7 +116,7 @@ columns in the data.
 // dims = [nRoleValues, 2]  →  Teacher uses window=4, Student uses window=2.
 const model = ena.fit(rows, {
   codes, units, conversations,
-  ordered: true,   // directed (n² connections) when using tensors
+  ordered: true,   // directed (n² connections); also works without a tensor
   tensor: {
     dims:         [2, 2],   // [nRoleValues=2, weight/window=2]
     dimsSender:   [0],      // axis 0 is a sender factor

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qe-libs/rena-wasm",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "JavaScript/WebAssembly ENA pipeline — thin orchestration layer over @qe-libs/libqe-wasm",
   "main": "src/index.js",
   "type": "module",
@@ -31,7 +31,7 @@
     "resolver": "<rootDir>/jest-resolver.cjs"
   },
   "dependencies": {
-    "@qe-libs/libqe-wasm": "^0.1.0"
+    "@qe-libs/libqe-wasm": "^0.1.5"
   },
   "devDependencies": {
     "jest": "^29.0.0"

package/src/index.js

@@ -43,7 +43,7 @@
 import loadLibQE from '@qe-libs/libqe-wasm';
 import { parseData } from './data.js';
 import {
-    accumulate, accumulateWithRows, sphereNorm, center,
+    sphereNorm, center,
     rotateSVD, rotateMeans, rotateGeneralized,
     project, nodePositions, spaceDistCorr,
 } from './pipeline.js';
@@ -187,6 +187,29 @@ class ENAModel {
     }
 }
 
+// ── weight models (= R's `weight.by`) ────────────────────────────────────────
+
+/**
+ * Map a rena-wasm weight-model name to the libqe weight model applied per line
+ * (before the per-unit sum) by libqe's finalize_row_connections:
+ *   'sqrt'          → 'sqrt'     (R weight.by = sqrt)
+ *   'log' | 'log1p' → 'log1p'    (log(x+1); guards log(0))
+ *   'product'       → 'product'  (the raw, non-binarized line counts)
+ * A falsy value, 'binary' or an unknown name returns null (binary / `binary`
+ * flag accumulation, no weight model).
+ * @param {string|false|undefined} name
+ * @returns {'sqrt'|'log1p'|'product'|null}
+ */
+function weightModelName(name) {
+    switch (name) {
+        case 'sqrt':    return 'sqrt';
+        case 'log':
+        case 'log1p':   return 'log1p';
+        case 'product': return 'product';
+        default:        return null;   // binary / off / unknown
+    }
+}
+
 // ── shared pipeline (post-accumulation) ──────────────────────────────────────
 
 function runPipeline(qe, rawNetworks, nUnits, nConnections, codes, unitLabels,
@@ -233,10 +256,11 @@ function runPipeline(qe, rawNetworks, nUnits, nConnections, codes, unitLabels,
     );
 
     // Node positions (LWS) → rotation.nodes + model.centroids
-    // libqe.node_positions expects centered-normed networks (pointsForProjection),
-    // not sphere-normed (lineWeights). Using lineWeights places code nodes in wrong locations.
+    // Matches rENA's lws.positions.sq, which regresses the projected points onto
+    // the SPHERE-normed line weights (enaset$line.weights) — not the centered
+    // networks.  Verified node-for-node against R rENA on rs.data.new.csv.
     const { nodes, centroids } = nodePositions(
-        qe, pointsForProjection, nUnits, nConnections, points, dims
+        qe, lineWeights, nUnits, nConnections, points, dims
     );
 
     // Variance explained (= R's model$variance)
@@ -291,10 +315,11 @@ export default async function loadENA() {
          * @param {string[]} opts.codes            - Code column names
          * @param {string[]} opts.units            - Unit identifier column(s)
          * @param {string[]} opts.conversations    - Conversation identifier column(s)
-         * @param {number}   [opts.window=4]       - Backward window (simple path; ignored when tensor provided)
-         * @param {boolean}  [opts.binary=true]    - Binarise co-occurrences (simple path only)
-         * @param {boolean}  [opts.ordered=false]  - Directed networks (tensor path only)
-         * @param {object}   [opts.tensor]         - Context tensor definition
+         * @param {number}   [opts.window=4]       - Backward window; builds defaultTensor(window) when no tensor is given
+         * @param {boolean}  [opts.binary=true]    - Binarise each line's co-occurrences (unordered; ignored when weightModel is set)
+         * @param {boolean}  [opts.ordered=false]  - Directed networks
+         * @param {object}   [opts.tensor]         - Context tensor definition (overrides window)
+         * @param {string}   [opts.weightModel]    - 'product' | 'sqrt' | 'log' (alias 'log1p'); per line, before the unit sum
          * @param {string}   [opts.rotation='svd'] - 'svd', 'mean', or 'generalized'
          * @param {number[]} [opts.groupA]         - Unit indices for means rotation group A
          * @param {number[]} [opts.groupB]         - Unit indices for means rotation group B
@@ -318,33 +343,33 @@ export default async function loadENA() {
                 gParams,
                 dims                 = 2,
                 codeMask,
+                weightModel,
             } = opts;
 
             if (!codes?.length)         throw new Error('opts.codes is required');
             if (!units?.length)         throw new Error('opts.units is required');
             if (!conversations?.length) throw new Error('opts.conversations is required');
 
+            // Weight model = R's `weight.by`. R applies it per LINE (each row's
+            // "product" co-occurrence counts) BEFORE summing per unit, mirroring
+            // accumulate.data.R (lapply(.SD, weight.by) over the per-line
+            // co-occurrence table, then per-unit aggregation). Because
+            // sqrt(Σ) ≠ Σsqrt, libqe applies it to each row's counts inside
+            // accumulateTensor, not to the unit-summed network.
+            const weight = weightModelName(weightModel);
+
             const { codeMatrix, nRows, nCodes, nUnits, unitLabels,
                     unitOf, convoGroups, metaData } =
                 parseData(rows, codes, units, conversations);
 
-            let rawNetworks, rowConnectionCounts = null, nConnections;
-
-            if (tensorDef) {
-                rawNetworks  = accumulateTensor(
-                    qe, rows, codeMatrix, nRows, nCodes, nUnits,
-                    unitOf, convoGroups, tensorDef, ordered
-                );
-                nConnections = ordered ? nCodes * nCodes : qe.choose_two(nCodes);
-            } else {
-                const accumulated = accumulateWithRows(
-                    qe, codeMatrix, nRows, nCodes, nUnits,
-                    unitOf, convoGroups, windowSize, binary
-                );
-                rawNetworks = accumulated.networks;
-                rowConnectionCounts = accumulated.rowConnectionCounts;
-                nConnections = qe.choose_two(nCodes);
-            }
+            // Every model accumulates through the tensor path; a plain moving
+            // window is expressed as defaultTensor(window).
+            const { networks: rawNetworks, rowConnectionCounts } = accumulateTensor(
+                qe, rows, codeMatrix, nRows, nCodes, nUnits,
+                unitOf, convoGroups, tensorDef ?? defaultTensor(windowSize),
+                ordered, binary, weight
+            );
+            const nConnections = ordered ? nCodes * nCodes : qe.choose_two(nCodes);
 
             // Apply code masking by zeroing out the masked connection columns across all units
             if (codeMask && codeMask.length === codes.length) {
@@ -385,7 +410,7 @@ export default async function loadENA() {
          * Returns raw (un-normalised) network vectors.
          *
          * @param {Object[]} rows
-         * @param {object}   opts  - codes, units, conversations, window, binary, ordered, tensor
+         * @param {object}   opts  - codes, units, conversations, window, binary, ordered, tensor, weightModel
          * @returns {{
          *   connectionCounts: Float64Array,
          *   rowConnectionCounts: Float64Array | null,
@@ -405,29 +430,19 @@ export default async function loadENA() {
                 ordered              = false,
                 tensor:  tensorDef,
                 codeMask,
+                weightModel,
             } = opts;
 
             const { codeMatrix, nRows, nCodes, nUnits, unitLabels,
                     unitOf, convoGroups, metaData } =
                 parseData(rows, codes, units, conversations);
 
-            let networks, rowConnectionCounts = null, nConnections;
-
-            if (tensorDef) {
-                networks     = accumulateTensor(
-                    qe, rows, codeMatrix, nRows, nCodes, nUnits,
-                    unitOf, convoGroups, tensorDef, ordered
-                );
-                nConnections = ordered ? nCodes * nCodes : qe.choose_two(nCodes);
-            } else {
-                const accumulated = accumulateWithRows(
-                    qe, codeMatrix, nRows, nCodes, nUnits,
-                    unitOf, convoGroups, windowSize, binary
-                );
-                networks = accumulated.networks;
-                rowConnectionCounts = accumulated.rowConnectionCounts;
-                nConnections = qe.choose_two(nCodes);
-            }
+            const { networks, rowConnectionCounts } = accumulateTensor(
+                qe, rows, codeMatrix, nRows, nCodes, nUnits,
+                unitOf, convoGroups, tensorDef ?? defaultTensor(windowSize),
+                ordered, binary, weightModelName(weightModel)
+            );
+            const nConnections = ordered ? nCodes * nCodes : qe.choose_two(nCodes);
 
             // Apply code masking by zeroing out the masked connection columns across all units
             if (codeMask && codeMask.length === codes.length) {
@@ -465,7 +480,8 @@ export default async function loadENA() {
                 // Retained so tuneWindowSize() can rebuild at other window sizes
                 // (= R's ENAAccumulation$`_function.call`).
                 _call: { rows, codes, units, conversations,
-                         window: windowSize, binary, ordered, tensor: tensorDef },
+                         window: windowSize, binary, ordered, tensor: tensorDef,
+                         weightModel },
             };
         },
 
@@ -503,21 +519,22 @@ export default async function loadENA() {
                 'maxSize must be greater than minSize to compare windows.'
             );
 
-            const { rows, codes, units, conversations, binary } = call;
+            const { rows, codes, units, conversations, binary, ordered, weightModel } = call;
 
             // Parse once; only the window size changes between iterations.
             const { codeMatrix, nRows, nCodes, nUnits, unitLabels,
                     unitOf, convoGroups, metaData } =
                 parseData(rows, codes, units, conversations);
-            const nConnections = qe.choose_two(nCodes);
+            const nConnections = ordered ? nCodes * nCodes : qe.choose_two(nCodes);
 
             // 1. Rebuild + fit at each window, collecting unit points.
             const dims = 2;
             const allPoints = [];
             for (const w of windowRange) {
-                const raw = accumulate(
-                    qe, codeMatrix, nRows, nCodes, nUnits,
-                    unitOf, convoGroups, w, binary
+                const { networks: raw } = accumulateTensor(
+                    qe, rows, codeMatrix, nRows, nCodes, nUnits,
+                    unitOf, convoGroups, defaultTensor(w), ordered, binary,
+                    weightModelName(weightModel)
                 );
                 const model = runPipeline(
                     qe, raw, nUnits, nConnections, codes,
@@ -543,10 +560,71 @@ export default async function loadENA() {
 
             // 4. Rebuild the accumulation at the selected window size.
             return api.accumulate(rows, {
-                codes, units, conversations, window: bestWindow, binary,
+                codes, units, conversations, window: bestWindow, binary, ordered,
+                weightModel,
             });
         },
 
+        /**
+         * Estimate the moving-window size via Cross-Covariance Decay (CCD)
+         * (= R's ena.ccd). Computes the noise-corrected cross-covariance decay
+         * curves over lags and returns the half-life lag as the window size.
+         *
+         * Unlike tuneWindowSize (which rebuilds+fits a full SVD model at each
+         * window), CCD runs directly on the raw code matrix per conversation —
+         * no accumulation/rotation — via the shared libqe kernel.
+         *
+         * @param {Object[]} rows
+         * @param {object}   opts
+         * @param {string[]} opts.codes            - Code column names
+         * @param {string[]} opts.conversations    - Conversation identifier column(s)
+         * @param {number}   [opts.maxWindow=20]   - Maximum lag to evaluate
+         * @param {number}   [opts.minOverlap=10]  - Minimum overlapping rows per conversation at a lag
+         * @returns {{
+         *   window_size:          number,
+         *   peak_lag:             number,
+         *   lag:                  number[],
+         *   frob:                 number[],
+         *   frob_sq_unbiased:     number[],
+         *   frob_unbiased_signed: number[],
+         *   total_weight:         number[],
+         * }}
+         */
+        ccd(rows, opts = {}) {
+            const { codes, conversations, maxWindow = 20, minOverlap = 10 } = opts;
+            if (!codes?.length)         throw new Error('opts.codes is required');
+            if (!conversations?.length) throw new Error('opts.conversations is required');
+
+            // Units are irrelevant to CCD; reuse conversations as a placeholder
+            // so parseData can build codeMatrix + convoGroups.
+            const { codeMatrix, nRows, nCodes, convoGroups } =
+                parseData(rows, codes, conversations, conversations);
+
+            // Flatten conversation row groups into (sizes, indices) for the kernel.
+            const groupSizes = [];
+            const rowIndices = [];
+            for (const rowIdxs of convoGroups.values()) {
+                groupSizes.push(rowIdxs.length);
+                for (const ri of rowIdxs) rowIndices.push(ri);
+            }
+
+            return qe.ccd_window(
+                codeMatrix, nRows, nCodes, groupSizes, rowIndices, maxWindow, minOverlap
+            );
+        },
+
+        /**
+         * Convenience wrapper returning only the estimated window size
+         * (= R's ena.ccd.window).
+         *
+         * @param {Object[]} rows
+         * @param {object}   opts  - see ccd()
+         * @returns {number}  estimated window size
+         */
+        ccdWindow(rows, opts = {}) {
+            return api.ccd(rows, opts).window_size;
+        },
+
         /**
          * Per-dimension t-based confidence intervals around the column means.
          * Matches R's conf.ints / libqe::mean_ci.
@@ -593,10 +671,135 @@ export default async function loadENA() {
             return qe.group_stats(g1Points, nG1, dims, g2Points, nG2, dims);
         },
 
+        /**
+         * PRIA — find the largest set of codes (up to removeNum) that can be
+         * removed while keeping the model's goodness-of-fit within `threshold`
+         * of the full model.  Brute-force subset search matching R
+         * PRIA::pria(): for k = 1..removeNum, over every k-subset of codes,
+         * build the reduced model (fit with a codeMask that drops every
+         * connection touching a removed code), gate on
+         * min_d(gof_reduced[d] / gof_full[d]) >= threshold where gof is the
+         * per-dimension ena_correlation(points, centroids), and keep the subset
+         * with the MOST codes removed, then the highest reduced dim-1 variance.
+         *
+         * @returns {{ removed: string[], removedIndices: number[], k: number,
+         *             variance: (number|null) }}
+         */
+        pria(rows, opts = {}) {
+            const {
+                codes, units, conversations,
+                window: windowSize = 4, binary = true, ordered = false,
+                rotation = 'svd', dims = 2, gParams, groupA, groupB,
+                removeNum = 3, threshold = 0.95,
+            } = opts;
+            if (!codes?.length)         throw new Error('opts.codes is required');
+            if (!units?.length)         throw new Error('opts.units is required');
+            if (!conversations?.length) throw new Error('opts.conversations is required');
+
+            const m  = codes.length;
+            const rn = Math.min(removeNum, m - 3);   // never reduce below 3 codes
+            const empty = { removed: [], removedIndices: [], k: 0, variance: null };
+            if (rn < 1) return empty;
+
+            const gofDims  = Math.min(dims, 2);       // R scores on dims 1:2
+            const baseOpts = { codes, units, conversations, window: windowSize,
+                               binary, ordered, rotation, dims, gParams, groupA, groupB };
+
+            const D = gofDims;  // score on the first 2 dims (R's get_pria_scores_2Ds)
+            // Extract a D-column submatrix (given row indices) from a flat
+            // row-major (nRows × dims) array.
+            const sub = (flat, rowIdxs) => {
+                const out = new Float64Array(rowIdxs.length * D);
+                rowIdxs.forEach((r, t) => { for (let d = 0; d < D; d++) out[t * D + d] = flat[r * dims + d]; });
+                return out;
+            };
+            // ena_correlation(A, B) → [r_dim0, r_dim1] (col 0 of the dims×3 result).
+            const corr2 = (Aflat, Bflat, nRows) => {
+                const r = qe.ena_correlation(Array.from(Aflat), nRows, D,
+                                             Array.from(Bflat), nRows, D, 0.95);
+                const out = [];
+                for (let d = 0; d < D; d++) out.push(r.data[d * 3]);
+                return out;
+            };
+            const full   = api.fit(rows, baseOpts);
+            const nUnits = full.nUnits;
+            const unitRows = Array.from({ length: nUnits }, (_, i) => i);
+            const gofOf    = (mdl) => corr2(sub(mdl.points, unitRows), sub(mdl.model.centroids, unitRows), nUnits);
+            const gFull    = gofOf(full);
+            const fullPts2 = sub(full.points, unitRows);
+
+            // All k-subsets of [0..m) as index arrays.
+            const combos = (n, k) => {
+                const res = [], cur = [];
+                const rec = (start) => {
+                    if (cur.length === k) { res.push(cur.slice()); return; }
+                    for (let i = start; i < n; i++) { cur.push(i); rec(i + 1); cur.pop(); }
+                };
+                rec(0);
+                return res;
+            };
+
+            let bestK = 0, bestVar = -Infinity, bestRemoved = [];
+            for (let k = 1; k <= rn; k++) {
+                for (const idxs of combos(m, k)) {
+                    const removedSet = new Set(idxs);
+                    const mask = [];
+                    for (let i = 0; i < m; i++) {
+                        const row = [];
+                        for (let j = 0; j < m; j++) {
+                            row.push((removedSet.has(i) || removedSet.has(j)) ? 0 : 1);
+                        }
+                        mask.push(row);
+                    }
+                    const red = api.fit(rows, { ...baseOpts, codeMask: mask });
+
+                    // Gate 1 — goodness-of-fit ratio vs full, per dim.
+                    const gRed = gofOf(red);
+                    let pass = true;
+                    for (let d = 0; d < D; d++) {
+                        if (gFull[d] === 0 || gRed[d] / gFull[d] < threshold) { pass = false; break; }
+                    }
+                    if (!pass) continue;
+
+                    // Gate 2 — reduced points AND retained-code nodes must each
+                    // correlate >= threshold with the full model (per dim, with a
+                    // per-dim sign flip that negates the node corr alongside it).
+                    const retained = [];
+                    for (let i = 0; i < m; i++) if (!removedSet.has(i)) retained.push(i);
+                    let [pc1, pc2] = corr2(fullPts2, sub(red.points, unitRows), nUnits);
+                    let [nc1, nc2] = corr2(sub(full.rotation.nodes, retained),
+                                           sub(red.rotation.nodes, retained), retained.length);
+                    if (pc1 < 0) { pc1 = -pc1; nc1 = -nc1; }
+                    if (pc2 < 0) { pc2 = -pc2; nc2 = -nc2; }
+                    if (Math.min(pc1, pc2, nc1, nc2) < threshold) continue;
+
+                    // Dim-1 variance proportion over the FULL rotation spectrum
+                    // (= R's set$model$variance[1] = diag(var(points.rotated))/sum);
+                    // NOT model.variance, which is the 2-dim projected ratio.
+                    const ev = red.rotation.eigenvalues;
+                    let evSum = 0; for (let i = 0; i < ev.length; i++) evSum += ev[i];
+                    const vr1 = evSum > 0 ? ev[0] / evSum : 0;
+                    // Prefer more codes removed; tie-break on higher dim-1 variance.
+                    if (k > bestK || (k === bestK && vr1 > bestVar)) {
+                        bestK = k; bestVar = vr1; bestRemoved = idxs.slice();
+                    }
+                }
+            }
+            return {
+                removed:        bestRemoved.map(i => codes[i]),
+                removedIndices: bestRemoved,
+                k:              bestK,
+                variance:       bestVar === -Infinity ? null : bestVar,
+            };
+        },
+
         /**
          * Helpers re-exported for consumers who want to build their own pipeline.
          */
         defaultTensor,
+
+        /** The underlying libqe WASM module, for custom low-level pipelines. */
+        qe,
     };
 
     return api;

package/src/pipeline.js

@@ -116,109 +116,6 @@ export function spaceDistCorr(A, B, m, d, maxSampleSize = 100000, rand = Math.ra
     return pearson(distA, distB);
 }
 
-// ── accumulation ─────────────────────────────────────────────────────────────
-
-/**
- * Accumulate windowed co-occurrences for all units across all conversations.
- *
- * For each conversation group, runs qe.accumulate_stanza() on the conversation's
- * rows to get per-row connection vectors, then folds each row's vector into its
- * owning unit's running sum.
- *
- * @param {object}      qe            libqe WASM module
- * @param {Float64Array} codeMatrix   n_rows × n_codes, row-major
- * @param {number}      nRows
- * @param {number}      nCodes
- * @param {number}      nUnits
- * @param {Int32Array}  unitOf        unit index per row
- * @param {Map}         convoGroups   convoIdx → [rowIdx, ...]
- * @param {number}      windowSize    backward window (rows)
- * @param {boolean}     binary        binarise co-occurrences
- *
- * @returns {Float64Array}  nUnits × nConnections, row-major
- */
-export function accumulate(qe, codeMatrix, nRows, nCodes, nUnits,
-                            unitOf, convoGroups, windowSize = 4, binary = true) {
-    const nConnections = qe.choose_two(nCodes);
-    const networks     = new Float64Array(nUnits * nConnections);
-
-    for (const [, rowIndices] of convoGroups) {
-        const nConvo = rowIndices.length;
-
-        // Extract code rows for this conversation (contiguous sub-matrix)
-        const convoCodes = new Float64Array(nConvo * nCodes);
-        for (let r = 0; r < nConvo; r++) {
-            const src = rowIndices[r];
-            convoCodes.set(
-                codeMatrix.subarray(src * nCodes, src * nCodes + nCodes),
-                r * nCodes
-            );
-        }
-
-        // Windowed accumulation — returns per-row connection vectors
-        const stanza = qe.accumulate_stanza(
-            convoCodes, nConvo, nCodes, windowSize, 0, binary
-        );
-        // stanza.data: nConvo × nConnections, row-major
-
-        // Fold each row into its unit's accumulator
-        for (let r = 0; r < nConvo; r++) {
-            const unit   = unitOf[rowIndices[r]];
-            const offset = r * nConnections;
-            for (let c = 0; c < nConnections; c++) {
-                networks[unit * nConnections + c] += stanza.data[offset + c];
-            }
-        }
-    }
-
-    return networks;
-}
-
-/**
- * Accumulate windowed co-occurrences and retain both per-unit and per-row
- * connection vectors.
- *
- * @returns {{ networks: Float64Array, rowConnectionCounts: Float64Array }}
- */
-export function accumulateWithRows(qe, codeMatrix, nRows, nCodes, nUnits,
-                                   unitOf, convoGroups, windowSize = 4, binary = true) {
-    const nConnections       = qe.choose_two(nCodes);
-    const networks           = new Float64Array(nUnits * nConnections);
-    const rowConnectionCounts = new Float64Array(nRows * nConnections);
-
-    for (const [, rowIndices] of convoGroups) {
-        const nConvo = rowIndices.length;
-
-        const convoCodes = new Float64Array(nConvo * nCodes);
-        for (let r = 0; r < nConvo; r++) {
-            const src = rowIndices[r];
-            convoCodes.set(
-                codeMatrix.subarray(src * nCodes, src * nCodes + nCodes),
-                r * nCodes
-            );
-        }
-
-        const stanza = qe.accumulate_stanza(
-            convoCodes, nConvo, nCodes, windowSize, 0, binary
-        );
-
-        for (let r = 0; r < nConvo; r++) {
-            const src    = rowIndices[r];
-            const unit   = unitOf[src];
-            const offset = r * nConnections;
-            const rowOut = src * nConnections;
-
-            for (let c = 0; c < nConnections; c++) {
-                const value = stanza.data[offset + c];
-                rowConnectionCounts[rowOut + c] = value;
-                networks[unit * nConnections + c] += value;
-            }
-        }
-    }
-
-    return { networks, rowConnectionCounts };
-}
-
 // ── normalization (sphere norm) ───────────────────────────────────────────────
 
 /**

package/src/tensor.js

@@ -122,6 +122,10 @@ export function inferFactorLevels(rows, factors) {
 /**
  * Accumulate tensor networks for all units across all conversations.
  *
+ * Every accumulation — including plain windowed ENA, via defaultTensor(window)
+ * — runs through here, so the per-line finalisation (fold / binarize / weight)
+ * lives in exactly one place.
+ *
  * @param {object}      qe             libqe WASM module
  * @param {Object[]}    rows           Full dataset
  * @param {Float64Array} codeMatrix   n_rows × n_codes, row-major
@@ -132,11 +136,21 @@ export function inferFactorLevels(rows, factors) {
  * @param {Map}         convoGroups    convoIdx → [rowIdx, ...]
  * @param {object}      tensorDef      Tensor definition (see module docstring)
  * @param {boolean}     ordered        true → directed (n²); false → undirected
+ * @param {boolean}     [binary=true]  binarize each folded row (unordered only);
+ *                                     used when no weight model is given
+ * @param {string|null} [weight=null]  libqe weight model applied per line before
+ *                                     the unit sum: 'binary' | 'product' |
+ *                                     'sqrt' | 'log1p'
  *
- * @returns {Float64Array}  nUnits × nConnections, row-major
+ * @returns {{ networks: Float64Array, rowConnectionCounts: Float64Array }}
+ *   networks            nUnits × nConnections, row-major
+ *   rowConnectionCounts nRows × nConnections, row-major — each row's finalised
+ *                       (folded / binarized / weighted) connection vector;
+ *                       rows sum by unit to `networks`
  */
 export function accumulateTensor(qe, rows, codeMatrix, nRows, nCodes, nUnits,
-                                  unitOf, convoGroups, tensorDef, ordered = false) {
+                                  unitOf, convoGroups, tensorDef, ordered = false,
+                                  binary = true, weight = null) {
     const {
         dims,
         dimsSender   = [],
@@ -154,7 +168,11 @@ export function accumulateTensor(qe, rows, codeMatrix, nRows, nCodes, nUnits,
         ? nCodes * nCodes
         : qe.choose_two(nCodes);
 
-    const networks = new Float64Array(nUnits * nConnections);
+    const networks            = new Float64Array(nUnits * nConnections);
+    const rowConnectionCounts = new Float64Array(nRows * nConnections);
+
+    // libqe weight argument: a weight-model name, or the legacy binary flag.
+    const kernelWeight = weight ?? binary;
 
     const dimsArr    = new Int32Array(dims);
     const senderArr  = new Int32Array(dimsSender);
@@ -191,6 +209,12 @@ export function accumulateTensor(qe, rows, codeMatrix, nRows, nCodes, nUnits,
         for (const [unit, localRows] of unitConvoRows) {
             const unitRowsArr = new Int32Array(localRows);
 
+            // Always accumulate the DIRECTED per-response-row counts (ordered
+            // kernel), exactly as tma does — it calls apply_tensor with the
+            // default ordered=TRUE and defers the ordered-vs-unordered decision
+            // to aggregation.  Passing the unordered flag here would make the
+            // kernel emit an already-symmetric matrix that the fold below would
+            // then double-count.
             const result = qe.accumulate_tensor_unit(
                 tensorData, dimsArr,
                 senderArr, receiverArr, modeArr,
@@ -198,17 +222,32 @@ export function accumulateTensor(qe, rows, codeMatrix, nRows, nCodes, nUnits,
                 unitRowsArr,
                 convoCodes, nConvo, nCodes,
                 times,
-                ordered
+                true
             );
 
-            // Add connection counts to this unit's accumulator
-            for (let c = 0; c < nConnections; c++) {
-                networks[unit * nConnections + c] += result.connection_counts[c];
+            // Finalise each raw per-response-row connection vector with libqe's
+            // shared kernel, exactly as tma does in R: fold to the upper
+            // triangle (unordered) or keep the directed row (ordered), then
+            // apply the weight model per line (binary clamp, product, sqrt,
+            // log1p) before the per-unit sum. Row i is local row localRows[i].
+            const rcc = result.row_connection_counts;
+            const fin = qe.finalize_row_connections(
+                rcc.data, rcc.rows, rcc.cols, nCodes, ordered, kernelWeight
+            );
+            const unitOff = unit * nConnections;
+            for (let i = 0; i < fin.rows; i++) {
+                const rowOff = rowIndices[localRows[i]] * nConnections;
+                const finOff = i * fin.cols;
+                for (let c = 0; c < nConnections; c++) {
+                    const v = fin.data[finOff + c];
+                    rowConnectionCounts[rowOff + c] = v;
+                    networks[unitOff + c] += v;
+                }
             }
         }
     }
 
-    return networks;
+    return { networks, rowConnectionCounts };
 }
 
 /**