@qe-libs/rena-wasm 0.1.4 → 0.1.6

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,50 @@ 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' });
+```
+
+---
+
+## Reduced-Code Search (PRIA)
+
+`pria()` finds the largest set of codes (up to `removeNum`, never leaving
+fewer than 3) whose removal keeps the model within `threshold` of the full
+model — the same search, gates and tie-break as R's `PRIA::pria()`. It takes
+the same options as `fit()` (rotation, `weightModel`, `tensor`, `codeMask`,
+…), so it scores the model you display.
+
+```js
+const { removed, k, variance } = ena.pria(rows, {
+  codes, units, conversations, window: 4,
+  rotation: 'mean', groupA, groupB,
+  removeNum: 3, threshold: 0.95,
+});
+// removed  → code names to drop (most codes first, then highest dim-1 variance)
+// variance → dim-1 share of variance in the chosen reduced model
+```
+
+---
+
 ## Accumulation Only
 
 Returns raw (un-normalised) network vectors without running the full pipeline.
@@ -92,7 +136,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.4",
+  "version": "0.1.6",
   "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.4"
+    "@qe-libs/libqe-wasm": "^0.1.5"
   },
   "devDependencies": {
     "jest": "^29.0.0"

package/src/index.js

@@ -190,30 +190,67 @@ class ENAModel {
 // ── weight models (= R's `weight.by`) ────────────────────────────────────────
 
 /**
- * Map a weight-model name to its element-wise transform, matching the webtool's
- * server.js mapping to R weight.by functions:
- *   'sqrt'    → Math.sqrt          (R "sqrt")
- *   'log'     → Math.log1p         (R "log1p", i.e. log(x+1); guards log(0))
- *   'product' → identity           (raw non-binary counts; R's "product" string
- *                                    is not a function, so no transform)
- * A falsy value or 'binary' returns null (binary accumulation, no transform).
+ * 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 {((x:number)=>number)|null}
+ * @returns {'sqrt'|'log1p'|'product'|null}
  */
-function weightModelTransform(name) {
+function weightModelName(name) {
     switch (name) {
-        case 'sqrt':    return Math.sqrt;
-        case 'log':     return Math.log1p;
-        case 'product': return (x) => x;
+        case 'sqrt':    return 'sqrt';
+        case 'log':
+        case 'log1p':   return 'log1p';
+        case 'product': return 'product';
         default:        return null;   // binary / off / unknown
     }
 }
 
+// ── code masking ─────────────────────────────────────────────────────────────
+
+/**
+ * Zero, in place, every connection column the code mask excludes.
+ * codeMask is an nCodes × nCodes 0/1 matrix; a 0 at [a][b] drops the
+ * connection between codes a and b (unordered: either orientation drops the
+ * pair; ordered: codeMask[j][i] === 0 drops the directed column i*n + j).
+ *
+ * @param {Float64Array} networks   nUnits × nConnections, row-major
+ * @param {number[][]}   codeMask
+ * @param {number}       nCodes
+ * @param {number}       nUnits
+ * @param {number}       nConnections
+ * @param {boolean}      ordered
+ */
+function applyCodeMask(networks, codeMask, nCodes, nUnits, nConnections, ordered) {
+    if (!codeMask || codeMask.length !== nCodes) return;
+    const zeroColumn = (k) => {
+        for (let u = 0; u < nUnits; u++) networks[u * nConnections + k] = 0;
+    };
+    if (ordered) {
+        for (let j = 0; j < nCodes; j++)
+            for (let i = 0; i < nCodes; i++)
+                if (codeMask[j] && codeMask[j][i] === 0) zeroColumn(i * nCodes + j);
+        return;
+    }
+    let k = 0;
+    for (let col = 1; col < nCodes; col++) {
+        for (let row = 0; row < col; row++) {
+            if ((codeMask[row] && codeMask[row][col] === 0) ||
+                (codeMask[col] && codeMask[col][row] === 0)) zeroColumn(k);
+            k++;
+        }
+    }
+}
+
 // ── shared pipeline (post-accumulation) ──────────────────────────────────────
 
 function runPipeline(qe, rawNetworks, nUnits, nConnections, codes, unitLabels,
                      metaData, rotMethod, groupA, groupB, dims, gParams,
-                     rowConnectionCounts = null) {
+                     rowConnectionCounts = null, directedNodes = false) {
     const connectionNames = qe.connection_names(codes);
 
     // Sphere norm → lineWeights (= R's set$line.weights)
@@ -240,6 +277,9 @@ function runPipeline(qe, rawNetworks, nUnits, nConnections, codes, unitLabels,
         rot = rotateSVD(qe, pointsForProjection, nUnits, nConnections);
     }
 
+    // Never ask for more dimensions than the rotation has columns.
+    dims = Math.min(dims, rot.rotCols);
+
     // Truncate rotation matrix to dims columns (= R's set$rotation.matrix)
     const rotationMatrix = new Float64Array(rot.rotRows * dims);
     for (let r = 0; r < rot.rotRows; r++)
@@ -258,8 +298,10 @@ function runPipeline(qe, rawNetworks, nUnits, nConnections, codes, unitLabels,
     // 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.
+    // `directedNodes` (ordered networks, used by pria()) solves with libqe's
+    // directed_node_positions, as rENA's optimize() does for ordered sets.
     const { nodes, centroids } = nodePositions(
-        qe, lineWeights, nUnits, nConnections, points, dims
+        qe, lineWeights, nUnits, nConnections, points, dims, directedNodes
     );
 
     // Variance explained (= R's model$variance)
@@ -318,7 +360,7 @@ export default async function loadENA() {
          * @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' (per-line, before the unit sum)
+         * @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
@@ -353,12 +395,9 @@ export default async function loadENA() {
             // "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, the transform is applied to each row's counts
-            // inside accumulateTensor, not to the unit-summed network.
-            // `product` is the non-binarized row counts themselves (identity);
-            // any weight model therefore forces non-binary accumulation.
-            const weightFn = weightModelTransform(weightModel);
-            const effBinary = weightFn ? false : binary;
+            // 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 } =
@@ -369,38 +408,11 @@ export default async function loadENA() {
             const { networks: rawNetworks, rowConnectionCounts } = accumulateTensor(
                 qe, rows, codeMatrix, nRows, nCodes, nUnits,
                 unitOf, convoGroups, tensorDef ?? defaultTensor(windowSize),
-                ordered, effBinary, weightFn
+                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) {
-                console.log('[rena-wasm] Applying code mask to raw networks...');
-                if (ordered) {
-                    for (let j = 0; j < codes.length; j++) {
-                        for (let i = 0; i < codes.length; i++) {
-                            if (codeMask[j] && codeMask[j][i] === 0) {
-                                const k = i * codes.length + j;
-                                for (let u = 0; u < nUnits; u++) {
-                                    rawNetworks[u * nConnections + k] = 0;
-                                }
-                            }
-                        }
-                    }
-                } else {
-                    let k = 0;
-                    for (let col = 1; col < codes.length; col++) {
-                        for (let row = 0; row < col; row++) {
-                            if ((codeMask[row] && codeMask[row][col] === 0) || (codeMask[col] && codeMask[col][row] === 0)) {
-                                for (let u = 0; u < nUnits; u++) {
-                                    rawNetworks[u * nConnections + k] = 0;
-                                }
-                            }
-                            k++;
-                        }
-                    }
-                }
-            }
+            applyCodeMask(rawNetworks, codeMask, codes.length, nUnits, nConnections, ordered);
 
             return runPipeline(qe, rawNetworks, nUnits, nConnections, codes,
                                unitLabels, metaData, rotMethod, groupA, groupB,
@@ -412,7 +424,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,
@@ -432,6 +444,7 @@ export default async function loadENA() {
                 ordered              = false,
                 tensor:  tensorDef,
                 codeMask,
+                weightModel,
             } = opts;
 
             const { codeMatrix, nRows, nCodes, nUnits, unitLabels,
@@ -441,38 +454,11 @@ export default async function loadENA() {
             const { networks, rowConnectionCounts } = accumulateTensor(
                 qe, rows, codeMatrix, nRows, nCodes, nUnits,
                 unitOf, convoGroups, tensorDef ?? defaultTensor(windowSize),
-                ordered, binary
+                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) {
-                console.log('[rena-wasm] Applying code mask to accumulated networks...');
-                if (ordered) {
-                    for (let j = 0; j < codes.length; j++) {
-                        for (let i = 0; i < codes.length; i++) {
-                            if (codeMask[j] && codeMask[j][i] === 0) {
-                                const k = i * codes.length + j;
-                                for (let u = 0; u < nUnits; u++) {
-                                    networks[u * nConnections + k] = 0;
-                                }
-                            }
-                        }
-                    }
-                } else {
-                    let k = 0;
-                    for (let col = 1; col < codes.length; col++) {
-                        for (let row = 0; row < col; row++) {
-                            if ((codeMask[row] && codeMask[row][col] === 0) || (codeMask[col] && codeMask[col][row] === 0)) {
-                                for (let u = 0; u < nUnits; u++) {
-                                    networks[u * nConnections + k] = 0;
-                                }
-                            }
-                            k++;
-                        }
-                    }
-                }
-            }
+            applyCodeMask(networks, codeMask, codes.length, nUnits, nConnections, ordered);
 
             const connectionNames = qe.connection_names(codes);
             return {
@@ -481,7 +467,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 },
             };
         },
 
@@ -519,7 +506,7 @@ export default async function loadENA() {
                 'maxSize must be greater than minSize to compare windows.'
             );
 
-            const { rows, codes, units, conversations, binary, ordered } = 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,
@@ -533,7 +520,8 @@ export default async function loadENA() {
             for (const w of windowRange) {
                 const { networks: raw } = accumulateTensor(
                     qe, rows, codeMatrix, nRows, nCodes, nUnits,
-                    unitOf, convoGroups, defaultTensor(w), ordered, binary
+                    unitOf, convoGroups, defaultTensor(w), ordered, binary,
+                    weightModelName(weightModel)
                 );
                 const model = runPipeline(
                     qe, raw, nUnits, nConnections, codes,
@@ -560,6 +548,7 @@ export default async function loadENA() {
             // 4. Rebuild the accumulation at the selected window size.
             return api.accumulate(rows, {
                 codes, units, conversations, window: bestWindow, binary, ordered,
+                weightModel,
             });
         },
 
@@ -674,12 +663,27 @@ export default async function loadENA() {
          * 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.
+         * build the reduced model (drop every connection touching a removed
+         * code, as R's remove.codes.from.accum does), gate on min_d(gof_reduced[d] / gof_full[d]) >= threshold where
+         * gof is the per-dimension ena_correlation(points, centroids) on dims
+         * 1:2, then on point and retained-node correlations, and keep the
+         * subset with the MOST codes removed, then the highest reduced dim-1
+         * variance (= R's reduced.set$model$variance[1]).
+         *
+         * The full and reduced models are built from the same accumulation as
+         * fit() with the same options — weightModel, tensor and codeMask
+         * included — so PRIA scores the model the caller actually displays.
+         * The data are accumulated once; each candidate only drops the removed
+         * codes' connection columns and re-runs normalize → center → rotate →
+         * project.
          *
+         * @param {Object[]} rows
+         * @param {object}   opts  - fit() options (codes, units, conversations,
+         *                           window, binary, ordered, tensor, weightModel,
+         *                           codeMask, rotation, groupA, groupB, gParams)
+         *                           plus removeNum (default 3) and threshold
+         *                           (default 0.95). `dims` is ignored: scoring
+         *                           uses dims 1:2 and the variance uses all dims.
          * @returns {{ removed: string[], removedIndices: number[], k: number,
          *             variance: (number|null) }}
          */
@@ -687,7 +691,8 @@ export default async function loadENA() {
             const {
                 codes, units, conversations,
                 window: windowSize = 4, binary = true, ordered = false,
-                rotation = 'svd', dims = 2, gParams, groupA, groupB,
+                tensor: tensorDef, weightModel, codeMask,
+                rotation = 'svd', gParams, groupA, groupB,
                 removeNum = 3, threshold = 0.95,
             } = opts;
             if (!codes?.length)         throw new Error('opts.codes is required');
@@ -699,32 +704,79 @@ export default async function loadENA() {
             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 };
+            // Accumulate once, exactly as fit() would for these options.
+            const { codeMatrix, nRows, nCodes, nUnits, unitLabels,
+                    unitOf, convoGroups, metaData } =
+                parseData(rows, codes, units, conversations);
+            const { networks: raw } = 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);
+            applyCodeMask(raw, codeMask, nCodes, nUnits, nConnections, ordered);
+
+            // Build a model from the accumulation with `removedSet`'s codes
+            // DROPPED -- their connection columns removed and the code list
+            // shortened -- as R PRIA's remove.codes.from.accum() does. Zeroing
+            // the columns instead is not equivalent: libqe's GMR rotation is
+            // sensitive to all-zero columns. All dimensions are kept so
+            // model.variance is the full-spectrum ratio R uses; the gates read
+            // only dims 1:2.
+            const fitWithout = (removedSet) => {
+                let networks = raw, keptCodes = codes, nConn = nConnections;
+                if (removedSet) {
+                    const keep = (c) => !removedSet.has(c);
+                    const cols = [];
+                    if (ordered) {
+                        for (let i = 0; i < nCodes; i++)
+                            for (let j = 0; j < nCodes; j++)
+                                if (keep(i) && keep(j)) cols.push(i * nCodes + j);
+                    } else {
+                        let k = 0;
+                        for (let col = 1; col < nCodes; col++)
+                            for (let row = 0; row < col; row++, k++)
+                                if (keep(row) && keep(col)) cols.push(k);
+                    }
+                    nConn = cols.length;
+                    networks = new Float64Array(nUnits * nConn);
+                    for (let u = 0; u < nUnits; u++)
+                        for (let c = 0; c < nConn; c++)
+                            networks[u * nConn + c] = raw[u * nConnections + cols[c]];
+                    keptCodes = codes.filter((_, i) => keep(i));
+                }
+                // Ordered models are scored with directed node positions (R's
+                // ordered pipeline), independent of how fit() places nodes.
+                return runPipeline(qe, networks, nUnits, nConn, keptCodes,
+                                   unitLabels, metaData, rotation, groupA, groupB,
+                                   nConn, gParams, null, ordered);
+            };
 
-            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 D = 2;  // score on the first 2 dims (R's get_pria_scores_2Ds)
+            // D-column submatrix (given row indices) of a model's flat
+            // row-major (nRows × model.dims) array.
+            const sub = (mdl, 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]; });
+                rowIdxs.forEach((r, t) => {
+                    for (let d = 0; d < D; d++) out[t * D + d] = flat[r * mdl.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 corr2 = (Aflat, Bflat, n) => {
+                const r = qe.ena_correlation(Array.from(Aflat), n, D,
+                                             Array.from(Bflat), n, 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 full     = fitWithout(null);
             const unitRows = Array.from({ length: nUnits }, (_, i) => i);
-            const gofOf    = (mdl) => corr2(sub(mdl.points, unitRows), sub(mdl.model.centroids, unitRows), nUnits);
+            const gofOf    = (mdl) => corr2(sub(mdl, mdl.points, unitRows),
+                                            sub(mdl, mdl.model.centroids, unitRows), nUnits);
             const gFull    = gofOf(full);
-            const fullPts2 = sub(full.points, unitRows);
+            const fullPts2 = sub(full, full.points, unitRows);
 
             // All k-subsets of [0..m) as index arrays.
             const combos = (n, k) => {
@@ -741,15 +793,7 @@ export default async function loadENA() {
             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 });
+                    const red = fitWithout(removedSet);
 
                     // Gate 1 — goodness-of-fit ratio vs full, per dim.
                     const gRed = gofOf(red);
@@ -762,21 +806,22 @@ export default async function loadENA() {
                     // 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).
+                    // The reduced model's nodes are the retained codes only, in order.
                     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);
+                    const reducedRows = retained.map((_, t) => t);
+                    let [pc1, pc2] = corr2(fullPts2, sub(red, red.points, unitRows), nUnits);
+                    let [nc1, nc2] = corr2(sub(full, full.rotation.nodes, retained),
+                                           sub(red, red.rotation.nodes, reducedRows), 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;
+                    // Dim-1 share of the variance of the projected points across
+                    // ALL dimensions (= R's reduced.set$model$variance[1]). Not the
+                    // eigenvalue ratio: means and GMR rotations report a zero
+                    // eigenvalue for their first axis.
+                    const vr1 = red.model.variance[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();

package/src/pipeline.js

@@ -301,14 +301,17 @@ export function project(centered, nUnits, nConnections, rotation, rotRows, rotCo
 /**
  * Compute code node positions via least-squares (LWS).
  *
+ * @param {boolean} [directed=false]  Use libqe's directed_node_positions (for
+ *   ordered n² networks), as rENA's optimize() does for ordered sets.
  * @returns {{ nodes: Float64Array, nodeRows: number, nodeCols: number,
  *             centroids: Float64Array|null }}
  *   nodes     — code positions in ENA space (= R's rotation$nodes)
  *   centroids — LWS unit centroid positions (= R's model$centroids), or null
  *               if libqe does not expose them
  */
-export function nodePositions(qe, networks, nUnits, nConnections, points, nDims) {
-    const r = qe.node_positions(networks, nUnits, nConnections, points, nUnits, nDims, nDims);
+export function nodePositions(qe, networks, nUnits, nConnections, points, nDims, directed = false) {
+    const solve = directed ? qe.directed_node_positions : qe.node_positions;
+    const r = solve(networks, nUnits, nConnections, points, nUnits, nDims, nDims);
     return {
         nodes:     new Float64Array(r.nodes.data),
         nodeRows:  r.nodes.rows,

package/src/tensor.js

@@ -119,54 +119,6 @@ export function inferFactorLevels(rows, factors) {
     return levels;
 }
 
-/**
- * Weighted aggregation of a unit's per-response-row directed connection counts.
- *
- * Mirrors the kernel's aggregate_row_connections but applies a weight-model
- * transform (R's weight.by) per LINE before the per-unit sum, so weight models
- * behave identically on the tensor path and the windowed path. Non-binary by
- * construction (the weight replaces the binarize step).
- *
- *   unordered: fold each directed row (m + mᵀ, upper triangle, column-major —
- *              the same order as choose_two/connection_names), weight each
- *              folded cell, then sum across rows.
- *   ordered:   weight each directed cell, then sum across rows.
- *
- * @param {Float64Array|number[]} data  Row-major (nRccRows × nCodes²) counts.
- * @param {number}   nRccRows           Number of response rows for this unit.
- * @param {number}   nCodes
- * @param {boolean}  ordered
- * @param {(x:number)=>number} weightFn
- * @returns {Float64Array}  length nCodes² (ordered) or choose_two(nCodes).
- */
-function aggregateRowConnectionsWeighted(data, nRccRows, nCodes, ordered, weightFn) {
-    const nSq = nCodes * nCodes;
-    if (ordered) {
-        const out = new Float64Array(nSq);
-        for (let r = 0; r < nRccRows; r++) {
-            const base = r * nSq;
-            for (let c = 0; c < nSq; c++) out[c] += weightFn(data[base + c]);
-        }
-        return out;
-    }
-    const nTri = (nCodes * (nCodes - 1)) / 2;
-    const out = new Float64Array(nTri);
-    for (let r = 0; r < nRccRows; r++) {
-        const base = r * nSq;
-        let k = 0;
-        for (let col = 1; col < nCodes; col++) {
-            for (let row = 0; row < col; row++) {
-                // fold: m(row,col) + m(col,row), column-major reshape of the row
-                const folded = data[base + col * nCodes + row] +
-                               data[base + row * nCodes + col];
-                out[k] += weightFn(folded);
-                k++;
-            }
-        }
-    }
-    return out;
-}
-
 /**
  * Accumulate tensor networks for all units across all conversations.
  *
@@ -184,8 +136,11 @@ function aggregateRowConnectionsWeighted(data, nRccRows, nCodes, ordered, weight
  * @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)
- * @param {((x:number)=>number)|null} [weightFn=null]  per-line weight transform
+ * @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 {{ networks: Float64Array, rowConnectionCounts: Float64Array }}
  *   networks            nUnits × nConnections, row-major
@@ -195,7 +150,7 @@ function aggregateRowConnectionsWeighted(data, nRccRows, nCodes, ordered, weight
  */
 export function accumulateTensor(qe, rows, codeMatrix, nRows, nCodes, nUnits,
                                   unitOf, convoGroups, tensorDef, ordered = false,
-                                  binary = true, weightFn = null) {
+                                  binary = true, weight = null) {
     const {
         dims,
         dimsSender   = [],
@@ -216,6 +171,9 @@ export function accumulateTensor(qe, rows, codeMatrix, nRows, nCodes, nUnits,
     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);
     const receiverArr = new Int32Array(dimsReceiver);
@@ -267,24 +225,23 @@ export function accumulateTensor(qe, rows, codeMatrix, nRows, nCodes, nUnits,
                 true
             );
 
-            // Finalise each raw per-response-row connection vector exactly as
-            // tma does in R: fold to the upper triangle and binarize per row
-            // (unordered), or keep the directed row (ordered). A weight model
-            // (R's weight.by) replaces the binarize step with its transform,
-            // applied per line before the per-unit sum. Unweighted rows go
-            // through the libqe kernel so fold/binarize semantics are shared
-            // across every binding. Row i of rcc is local row localRows[i].
+            // 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;
-            for (let i = 0; i < rcc.rows; i++) {
-                const one = rcc.data.slice(i * rcc.cols, (i + 1) * rcc.cols);
-                const rowVec = weightFn
-                    ? aggregateRowConnectionsWeighted(one, 1, nCodes, ordered, weightFn)
-                    : qe.aggregate_row_connections(one, 1, rcc.cols, nCodes, ordered, binary);
-                const rowOff  = rowIndices[localRows[i]] * nConnections;
-                const unitOff = unit * nConnections;
+            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++) {
-                    rowConnectionCounts[rowOff + c] = rowVec[c];
-                    networks[unitOff + c] += rowVec[c];
+                    const v = fin.data[finOff + c];
+                    rowConnectionCounts[rowOff + c] = v;
+                    networks[unitOff + c] += v;
                 }
             }
         }