@theseus-whale/dsh-continuity 0.0.0-stage → 4.12.2

package/src/facets/linear-probe.mjs

@@ -0,0 +1,43 @@
+/**
+ * Frozen-embedding linear probe.
+ * Weights are exported from a local logistic-regression training run.
+ */
+export function deserializeLinearProbe(raw) {
+  return {
+    slots: Object.fromEntries(Object.entries(raw?.slots ?? {}).map(([slot, value]) => [slot, {
+      classes: value.classes,
+      coef: value.coef,
+      intercept: value.intercept,
+    }])),
+  };
+}
+
+function softmax(scores) {
+  const max = Math.max(...scores);
+  const exp = scores.map((score) => Math.exp(score - max));
+  const sum = exp.reduce((a, b) => a + b, 0) || 1;
+  return exp.map((value) => value / sum);
+}
+
+export function predictLinearProbe(model, vector) {
+  const facets = {};
+  const confidence = {};
+  for (const [slot, slotModel] of Object.entries(model.slots)) {
+    const scores = slotModel.classes.map((_, classIndex) => {
+      let value = slotModel.intercept[classIndex] ?? 0;
+      const coef = slotModel.coef[classIndex];
+      for (let i = 0; i < vector.length; i += 1) value += coef[i] * vector[i];
+      return value;
+    });
+    const probs = softmax(scores);
+    let best = 0;
+    for (let i = 1; i < probs.length; i += 1) if (probs[i] > probs[best]) best = i;
+    facets[slot] = slotModel.classes[best];
+    confidence[slot] = probs[best];
+  }
+  return {
+    facets,
+    confidence,
+    unknown: !Object.keys(facets).some((slot) => slot !== 'random'),
+  };
+}

package/src/facets/load.mjs

@@ -0,0 +1,37 @@
+/**
+ * Resolve a facet query to loadable seqs.
+ * The plugin still uses the normal `continuity.load` path; this only turns
+ * alias/query facets into seqs and ranges.
+ */
+import fs from 'node:fs';
+import { queryFacets } from './index.mjs';
+import { loadIndex } from './store.mjs';
+import { aliasFacets } from './schema.mjs';
+
+export function loadFacetQuery(query, {
+  indexFile,
+  topK = 20,
+  maxSeqs = 200,
+} = {}) {
+  if (typeof indexFile !== 'string' || indexFile.length === 0) {
+    throw new Error('facet load: indexFile is required');
+  }
+  const index = loadIndex(indexFile);
+  const result = queryFacets(index, query, { topK });
+  const seqs = [];
+  for (const match of result.matches) {
+    const start = Number(match.seqStart);
+    const end = Number(match.seqEnd);
+    if (!Number.isInteger(start) || !Number.isInteger(end) || end < start) continue;
+    for (let seq = start; seq <= end && seqs.length < maxSeqs; seq += 1) seqs.push(seq);
+    if (seqs.length >= maxSeqs) break;
+  }
+  return {
+    query,
+    facets: aliasFacets(query),
+    ranges: result.ranges,
+    seqs,
+    truncated: seqs.length >= maxSeqs,
+  };
+}
+

package/src/facets/mlp-probe.mjs

@@ -0,0 +1,54 @@
+/**
+ * Frozen BGE + per-slot MLP head, exported from sklearn.
+ * Two dense layers with ReLU; output softmax.
+ */
+export function deserializeMlp(raw) {
+  return {
+    slots: Object.fromEntries(Object.entries(raw?.slots ?? {}).map(([slot, value]) => [slot, {
+      classes: value.classes,
+      w1: value.w1,
+      b1: value.b1,
+      w2: value.w2,
+      b2: value.b2,
+    }])),
+  };
+}
+
+function relu(value) {
+  return value > 0 ? value : 0;
+}
+
+function softmax(scores) {
+  const max = Math.max(...scores);
+  const exp = scores.map((score) => Math.exp(score - max));
+  const sum = exp.reduce((a, b) => a + b, 0) || 1;
+  return exp.map((value) => value / sum);
+}
+
+export function predictMlp(model, vector) {
+  const facets = {};
+  const confidence = {};
+  for (const [slot, slotModel] of Object.entries(model.slots)) {
+    const hidden = new Array(slotModel.b1.length);
+    for (let h = 0; h < hidden.length; h += 1) {
+      let sum = slotModel.b1[h];
+      for (let d = 0; d < vector.length; d += 1) sum += slotModel.w1[d][h] * vector[d];
+      hidden[h] = relu(sum);
+    }
+    const scores = slotModel.classes.map((_, c) => {
+      let sum = slotModel.b2[c];
+      for (let h = 0; h < hidden.length; h += 1) sum += slotModel.w2[h][c] * hidden[h];
+      return sum;
+    });
+    const probs = softmax(scores);
+    let best = 0;
+    for (let i = 1; i < probs.length; i += 1) if (probs[i] > probs[best]) best = i;
+    facets[slot] = slotModel.classes[best];
+    confidence[slot] = probs[best];
+  }
+  return {
+    facets,
+    confidence,
+    unknown: !Object.keys(facets).some((slot) => slot !== 'random'),
+  };
+}

package/src/facets/mlp-service.mjs

@@ -0,0 +1,53 @@
+/**
+ * Main-thread client for the MLP facet worker.
+ */
+import { Worker } from 'node:worker_threads';
+
+export function createMlpFacetService({ modelPath, embeddingModel, timeoutMs = 120000 } = {}) {
+  if (typeof modelPath !== 'string' || modelPath.length === 0) {
+    throw new Error('mlp service: modelPath is required');
+  }
+  const worker = new Worker(new URL('./mlp-worker.mjs', import.meta.url), {
+    workerData: { modelPath, embeddingModel },
+  });
+  let nextId = 1;
+  const pending = new Map();
+
+  worker.on('message', (message) => {
+    const entry = pending.get(message?.id);
+    if (entry === undefined) return;
+    pending.delete(message.id);
+    clearTimeout(entry.timer);
+    if (message.ok) entry.resolve(message.result);
+    else entry.reject(new Error(message.error));
+  });
+  worker.on('error', (error) => {
+    for (const entry of pending.values()) {
+      clearTimeout(entry.timer);
+      entry.reject(error);
+    }
+    pending.clear();
+  });
+
+  return {
+    extract(text) {
+      const id = nextId++;
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(new Error('mlp service: timeout'));
+        }, timeoutMs);
+        pending.set(id, { resolve, reject, timer });
+        worker.postMessage({ id, text: String(text ?? '') });
+      });
+    },
+    async close() {
+      for (const entry of pending.values()) {
+        clearTimeout(entry.timer);
+        entry.reject(new Error('mlp service: closed'));
+      }
+      pending.clear();
+      await worker.terminate();
+    },
+  };
+}

package/src/facets/mlp-worker.mjs

@@ -0,0 +1,26 @@
+/**
+ * MLP facet worker: BGE embedding + per-slot MLP in worker_threads.
+ */
+import { parentPort, workerData } from 'node:worker_threads';
+import fs from 'node:fs';
+import { embedTexts } from './embedding.mjs';
+import { deserializeMlp, predictMlp } from './mlp-probe.mjs';
+import { detectRandom } from './random.mjs';
+
+const model = deserializeMlp(JSON.parse(fs.readFileSync(workerData.modelPath, 'utf8')));
+const embeddingModel = workerData.embeddingModel;
+
+parentPort.on('message', async (message) => {
+  const id = message?.id;
+  try {
+    const text = String(message?.text ?? '');
+    const [vector] = await embedTexts([text], embeddingModel);
+    const result = predictMlp(model, vector);
+    result.facets.random = detectRandom(text).value;
+    if (result.facets.participants === undefined) result.facets.participants = '协作';
+    result.unknown = !Object.keys(result.facets).some((slot) => slot !== 'random');
+    parentPort.postMessage({ id, ok: true, result });
+  } catch (error) {
+    parentPort.postMessage({ id, ok: false, error: String(error?.message ?? error) });
+  }
+});

package/src/facets/online-knn.mjs

@@ -0,0 +1,58 @@
+/**
+ * Prequential (online) facet learner.
+ *
+ * At turn t it predicts from examples seen before t, then accepts the true
+ * label. No future labels are used.
+ */
+import { SLOTS, normalizeFacets } from './schema.mjs';
+
+function cosine(a, b) {
+  if (a.length !== b.length) return 0;
+  let dot = 0;
+  for (let i = 0; i < a.length; i += 1) dot += a[i] * b[i];
+  return dot;
+}
+
+export class OnlineFacetKnn {
+  constructor({ k = 5, minSimilarity = 0.2, minVote = 0.5 } = {}) {
+    this.k = k;
+    this.minSimilarity = minSimilarity;
+    this.minVote = minVote;
+    this.examples = [];
+  }
+
+  add(vector, facets) {
+    this.examples.push({ vector, facets: normalizeFacets(facets ?? {}) });
+  }
+
+  predict(vector) {
+    const facets = {};
+    const confidence = {};
+    for (const slot of SLOTS) {
+      const neighbors = this.examples
+        .filter((example) => example.facets[slot] !== undefined)
+        .map((example) => ({ example, score: cosine(vector, example.vector) }))
+        .filter((item) => item.score >= this.minSimilarity)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, this.k);
+      if (neighbors.length === 0) continue;
+      const votes = new Map();
+      let total = 0;
+      for (const item of neighbors) {
+        const value = item.example.facets[slot];
+        votes.set(value, (votes.get(value) ?? 0) + item.score);
+        total += item.score;
+      }
+      const [value, weight] = [...votes.entries()].sort((a, b) => b[1] - a[1])[0];
+      const vote = total === 0 ? 0 : weight / total;
+      if (vote < this.minVote) continue;
+      facets[slot] = value;
+      confidence[slot] = vote;
+    }
+    return {
+      facets,
+      confidence,
+      unknown: !Object.keys(facets).some((slot) => slot !== 'random'),
+    };
+  }
+}

package/src/facets/online-models.mjs

@@ -0,0 +1,227 @@
+/**
+ * True incremental facet learners.
+ * All consume one labelled turn at a time; no batch retraining.
+ */
+import { SLOTS, normalizeFacets } from './schema.mjs';
+
+function cosine(a, b) {
+  let dot = 0;
+  for (let i = 0; i < a.length; i += 1) dot += a[i] * b[i];
+  return dot;
+}
+
+function softmax(scores) {
+  const max = Math.max(...scores);
+  const exp = scores.map((score) => Math.exp(score - max));
+  const sum = exp.reduce((a, b) => a + b, 0) || 1;
+  return exp.map((value) => value / sum);
+}
+
+function result(facets, confidence) {
+  return {
+    facets,
+    confidence,
+    unknown: !Object.keys(facets).some((slot) => slot !== 'random'),
+  };
+}
+
+/** Running mean per facet value, cosine nearest centroid. */
+export class OnlineCentroid {
+  constructor({ minSimilarity = 0.15 } = {}) {
+    this.minSimilarity = minSimilarity;
+    this.state = Object.fromEntries(SLOTS.map((slot) => [slot, new Map()]));
+  }
+
+  predict(vector) {
+    const facets = {};
+    const confidence = {};
+    for (const slot of SLOTS) {
+      let best = null;
+      for (const [value, cell] of this.state[slot]) {
+        if (cell.count === 0) continue;
+        const centroid = cell.sum.map((x) => x / cell.count);
+        const score = cosine(vector, centroid);
+        if (best === null || score > best.score) best = { value, score };
+      }
+      if (best === null || best.score < this.minSimilarity) continue;
+      facets[slot] = best.value;
+      confidence[slot] = best.score;
+    }
+    return result(facets, confidence);
+  }
+
+  update(vector, facets) {
+    for (const [slot, value] of Object.entries(normalizeFacets(facets ?? {}))) {
+      let cell = this.state[slot].get(value);
+      if (cell === undefined) {
+        cell = { count: 0, sum: new Array(vector.length).fill(0) };
+        this.state[slot].set(value, cell);
+      }
+      cell.count += 1;
+      for (let i = 0; i < vector.length; i += 1) cell.sum[i] += vector[i];
+    }
+  }
+}
+
+/** Running mean + diagonal variance, Gaussian-like score. */
+export class OnlineCentroidVariance {
+  constructor({ minSimilarity = 0.1, varianceWeight = 0.5 } = {}) {
+    this.minSimilarity = minSimilarity;
+    this.varianceWeight = varianceWeight;
+    this.state = Object.fromEntries(SLOTS.map((slot) => [slot, new Map()]));
+  }
+
+  predict(vector) {
+    const facets = {};
+    const confidence = {};
+    for (const slot of SLOTS) {
+      let best = null;
+      for (const [value, cell] of this.state[slot]) {
+        if (cell.count < 2) continue;
+        let dot = 0;
+        let dist = 0;
+        for (let i = 0; i < vector.length; i += 1) {
+          const mean = cell.sum[i] / cell.count;
+          const variance = Math.max(1e-6, cell.sumsq[i] / cell.count - mean * mean);
+          dot += vector[i] * mean;
+          dist += ((vector[i] - mean) ** 2) / variance;
+        }
+        const score = dot - this.varianceWeight * (dist / vector.length);
+        if (best === null || score > best.score) best = { value, score };
+      }
+      if (best === null || best.score < this.minSimilarity) continue;
+      facets[slot] = best.value;
+      confidence[slot] = best.score;
+    }
+    return result(facets, confidence);
+  }
+
+  update(vector, facets) {
+    for (const [slot, value] of Object.entries(normalizeFacets(facets ?? {}))) {
+      let cell = this.state[slot].get(value);
+      if (cell === undefined) {
+        cell = {
+          count: 0,
+          sum: new Array(vector.length).fill(0),
+          sumsq: new Array(vector.length).fill(0),
+        };
+        this.state[slot].set(value, cell);
+      }
+      cell.count += 1;
+      for (let i = 0; i < vector.length; i += 1) {
+        cell.sum[i] += vector[i];
+        cell.sumsq[i] += vector[i] * vector[i];
+      }
+    }
+  }
+}
+
+function tokens(text) {
+  const raw = String(text ?? '').toLowerCase();
+  const words = raw.match(/[a-z0-9_]+/g) ?? [];
+  const chinese = [...raw.replace(/[^\u4e00-\u9fff]/g, '')];
+  const bigrams = [];
+  for (let i = 0; i + 1 < chinese.length; i += 1) bigrams.push(chinese[i] + chinese[i + 1]);
+  return [...words, ...bigrams];
+}
+
+/** Multinomial Naive Bayes with additive smoothing. */
+export class OnlineNaiveBayes {
+  constructor({ alpha = 1 } = {}) {
+    this.alpha = alpha;
+    this.state = Object.fromEntries(SLOTS.map((slot) => [slot, new Map()]));
+    this.prior = Object.fromEntries(SLOTS.map((slot) => [slot, new Map()]));
+    this.total = Object.fromEntries(SLOTS.map((slot) => [slot, 0]));
+  }
+
+  predict(text) {
+    const t = tokens(text);
+    const facets = {};
+    const confidence = {};
+    for (const slot of SLOTS) {
+      if (this.total[slot] === 0) continue;
+      let best = null;
+      for (const [value, docs] of this.prior[slot]) {
+        let score = Math.log((docs + this.alpha) / (this.total[slot] + this.alpha * this.prior[slot].size));
+        const counts = this.state[slot].get(value);
+        let tokenTotal = 0;
+        for (const count of counts.values()) tokenTotal += count;
+        for (const token of t) {
+          score += Math.log(((counts.get(token) ?? 0) + this.alpha) / (tokenTotal + this.alpha * counts.size));
+        }
+        if (best === null || score > best.score) best = { value, score };
+      }
+      if (best === null) continue;
+      facets[slot] = best.value;
+      confidence[slot] = best.score;
+    }
+    return result(facets, confidence);
+  }
+
+  update(text, facets) {
+    for (const [slot, value] of Object.entries(normalizeFacets(facets ?? {}))) {
+      if (!this.prior[slot].has(value)) {
+        this.prior[slot].set(value, 0);
+        this.state[slot].set(value, new Map());
+      }
+      this.prior[slot].set(value, this.prior[slot].get(value) + 1);
+      this.total[slot] += 1;
+      const counts = this.state[slot].get(value);
+      for (const token of tokens(text)) counts.set(token, (counts.get(token) ?? 0) + 1);
+    }
+  }
+}
+
+/** One-pass online softmax regression. */
+export class OnlineSoftmax {
+  constructor({ classes, dim, learningRate = 0.02 } = {}) {
+    this.classes = classes;
+    this.dim = dim;
+    this.learningRate = learningRate;
+    this.weights = new Map();
+    this.bias = new Map();
+  }
+
+  ensure(value) {
+    if (!this.weights.has(value)) {
+      this.weights.set(value, new Array(this.dim).fill(0));
+      this.bias.set(value, 0);
+    }
+  }
+
+  predict(vector) {
+    if (this.classes.length === 0) return result({}, {});
+    const scores = this.classes.map((value) => {
+      this.ensure(value);
+      const weights = this.weights.get(value);
+      let sum = this.bias.get(value);
+      for (let i = 0; i < vector.length; i += 1) sum += weights[i] * vector[i];
+      return sum;
+    });
+    const probs = softmax(scores);
+    let best = 0;
+    for (let i = 1; i < probs.length; i += 1) if (probs[i] > probs[best]) best = i;
+    return result({ activity: this.classes[best] }, { activity: probs[best] });
+  }
+
+  update(vector, facets) {
+    const truth = normalizeFacets(facets ?? {});
+    if (truth.activity === undefined) return;
+    this.ensure(truth.activity);
+    const scores = this.classes.map((value) => {
+      this.ensure(value);
+      const weights = this.weights.get(value);
+      let sum = this.bias.get(value);
+      for (let i = 0; i < vector.length; i += 1) sum += weights[i] * vector[i];
+      return sum;
+    });
+    const probs = softmax(scores);
+    for (let c = 0; c < this.classes.length; c += 1) {
+      const value = this.classes[c];
+      const gradient = probs[c] - (value === truth.activity ? 1 : 0);
+      const weights = this.weights.get(value);
+      for (let i = 0; i < vector.length; i += 1) weights[i] -= this.learningRate * gradient * vector[i];
+      this.bias.set(value, this.bias.get(value) - this.learningRate * gradient);
+    }
+  }
+}

package/src/facets/panel-state.mjs

@@ -0,0 +1,23 @@
+/**
+ * Read-only facet panel snapshot for the host endpoint.
+ * The UI works without this file; absence is reported as available:false.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const FACET_PANEL_FILE = 'facet-panel.json';
+
+export function buildFacetState({ home = process.env.USERPROFILE ?? process.env.HOME } = {}) {
+  const file = path.join(String(home ?? ''), '.dsh', 'continuity', FACET_PANEL_FILE);
+  try {
+    const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return { available: true, file, generatedAt: new Date().toISOString(), panel: raw };
+  } catch (error) {
+    return {
+      available: false,
+      file,
+      generatedAt: new Date().toISOString(),
+      reason: error?.code === 'ENOENT' ? 'missing' : String(error?.message ?? error),
+    };
+  }
+}

package/src/facets/panel.mjs

@@ -0,0 +1,73 @@
+/**
+ * Facet panel snapshot and load guidance.
+ *
+ * Pure data for a future panel/load hook: counts, current alias-facet pairs,
+ * a sensitivity curve, and one-line load hints. No UI dependency.
+ */
+import { DEFAULT_ALIASES, SLOTS, aliasFacets, normalizeFacets } from './schema.mjs';
+import { sensitivitySeries } from './sensitivity.mjs';
+import { buildFacetIndex, queryFacets } from './index.mjs';
+
+export function buildFacetPanel(entries, {
+  idf = null,
+  currentAlias = null,
+  aliases = DEFAULT_ALIASES,
+} = {}) {
+  const counts = Object.fromEntries(SLOTS.map((slot) => [slot, {}]));
+  let unknown = 0;
+  for (const entry of entries) {
+    const facets = normalizeFacets(entry.facets ?? {});
+    if (Object.keys(facets).length === 0) unknown += 1;
+    for (const [slot, value] of Object.entries(facets)) {
+      counts[slot][value] = (counts[slot][value] ?? 0) + 1;
+    }
+  }
+  const facetSum = Object.values(counts).reduce((sum, values) => (
+    sum + Object.values(values).reduce((a, b) => a + b, 0)
+  ), 0);
+  const alias = currentAlias !== null && aliases[String(currentAlias)] ? String(currentAlias) : null;
+  const query = alias === null ? {} : aliasFacets(alias);
+  const series = Object.keys(query).length === 0
+    ? []
+    : sensitivitySeries(entries, query, { idf });
+  return {
+    totalTurns: entries.length,
+    unknown,
+    facetSum,
+    counts,
+    currentTopic: alias === null ? null : {
+      alias,
+      facets: query,
+      pairs: Object.entries(query).map(([slot, value]) => ({
+        slot,
+        value,
+        turns: counts[slot]?.[value] ?? 0,
+      })),
+    },
+    curve: series,
+  };
+}
+
+export function buildLoadHint(entries, {
+  idf = null,
+  query = '跑团',
+  recentTurns = 20,
+  minScore = 0.2,
+  currentTurn = null,
+} = {}) {
+  const index = idf === null ? buildFacetIndex(entries) : { entries, idf, total: entries.length };
+  const result = queryFacets(index, query, { topK: entries.length });
+  if (result.matches.length === 0) return null;
+  const latestTurn = currentTurn ?? Math.max(...entries.map((entry) => entry.turn));
+  const recent = result.matches.filter((hit) => latestTurn - hit.turn <= recentTurns);
+  if (recent.length > 0) return null;
+  const top = result.matches[0];
+  if (top.score < minScore) return null;
+  const range = result.ranges[result.ranges.length - 1] ?? null;
+  return {
+    query,
+    text: `[话题线索] ${query}（候选 ${result.ranges.length} 段，最近 seq ${range?.seqStart ?? top.seqStart}–${range?.seqEnd ?? top.seqEnd}，置信 ${top.score.toFixed(2)}）`,
+    ranges: result.ranges,
+    top,
+  };
+}

package/src/facets/random.mjs

@@ -0,0 +1,26 @@
+/**
+ * Explicit random-signal detector.
+ *
+ * The last 100 turns contain no dice words, so a model trained only on them
+ * collapses to "无". This detector is the positive-label source for random:
+ * it is rule-based and deliberately narrow.
+ */
+export const RANDOM_HINTS = Object.freeze([
+  '掷骰',
+  '骰子',
+  '骰',
+  'd20',
+  '检定',
+  '抽卡',
+]);
+
+export function detectRandom(text) {
+  const raw = String(text ?? '');
+  const lower = raw.toLowerCase();
+  const hits = RANDOM_HINTS.filter((hint) => lower.includes(hint));
+  const dice = lower.match(/(?:^|[^a-z0-9])d\d{1,3}(?![a-z0-9])/g) ?? [];
+  const getRandom = lower.includes('get-random');
+  if (dice.length > 0) hits.push('dN');
+  if (getRandom) hits.push('get-random');
+  return { value: hits.length > 0 ? '有' : '无', hits: [...new Set(hits)] };
+}

package/src/facets/scanner.mjs

@@ -0,0 +1,35 @@
+/**
+ * Incremental scanner. It advances a seq cursor and queues unknowns; it never
+ * blocks the cursor waiting for a schema answer.
+ */
+import { normalizeFacets } from './schema.mjs';
+import { extractFacets } from './extract.mjs';
+
+export function emptyCursor(schemaVersion = 1) {
+  return { schemaVersion, lastSeq: -1, residual: [] };
+}
+
+export function scanRows(rows, cursor = emptyCursor(), { extract = extractFacets } = {}) {
+  const state = {
+    schemaVersion: cursor.schemaVersion ?? 1,
+    lastSeq: Number.isInteger(cursor.lastSeq) ? cursor.lastSeq : -1,
+    residual: Array.isArray(cursor.residual) ? [...cursor.residual] : [],
+  };
+  const entries = [];
+  for (const row of [...rows].sort((a, b) => a.seqStart - b.seqStart)) {
+    if (row.seqStart <= state.lastSeq) continue;
+    const extracted = row.facets !== undefined
+      ? { facets: normalizeFacets(row.facets), evidence: {}, unknown: false }
+      : extract(row.text ?? '');
+    const facets = extracted.facets ?? {};
+    const unknown = extracted.unknown === true || Object.keys(facets).length === 0;
+    if (unknown) state.residual.push({ seqStart: row.seqStart, seqEnd: row.seqEnd, turn: row.turn });
+    entries.push({ turn: row.turn, seqStart: row.seqStart, seqEnd: row.seqEnd, facets, unknown });
+    state.lastSeq = Math.max(state.lastSeq, row.seqEnd);
+  }
+  return { cursor: state, entries };
+}
+
+export function residualCount(cursor) {
+  return Array.isArray(cursor?.residual) ? cursor.residual.length : 0;
+}