@adhdev/mesh-shared 1.0.60-rc.69 → 1.0.60-rc.70

package/dist/index.mjs

@@ -1228,7 +1228,6 @@ var DAEMON_TO_DASHBOARD_P2P_TYPES = [
   "ping",
   "pong",
   "p2p_evicted",
-  "status_report",
   "status_event",
   "topic_update",
   "topic_update_chunk",
@@ -1237,7 +1236,8 @@ var DAEMON_TO_DASHBOARD_P2P_TYPES = [
   "session_io_error",
   "command_result",
   "command_result_chunk",
-  "response"
+  "response",
+  "transcript_topics_available"
 ];
 var isDaemonToDashboardP2PType = makeTypeGuard(DAEMON_TO_DASHBOARD_P2P_TYPES);
 function decodeDaemonToDashboardP2P(raw) {
@@ -1251,7 +1251,6 @@ function decodeDaemonToDashboardP2P(raw) {
     case "pong":
     case "p2p_evicted":
       return raw;
-    case "status_report":
     case "status_event":
       return isRecord(raw.payload) ? raw : null;
     case "topic_update":
@@ -1273,6 +1272,8 @@ function decodeDaemonToDashboardP2P(raw) {
     case "command_result":
     case "response":
       return isNonEmptyString(raw.id) ? raw : null;
+    case "transcript_topics_available":
+      return Array.isArray(raw.topics) && raw.topics.every((topic) => typeof topic === "string") ? { type: raw.type, topics: raw.topics } : null;
   }
 }
 var DASHBOARD_P2P_MESSAGE_KINDS = [
@@ -3167,6 +3168,393 @@ function touchedFilesOutsideOwnership(touched, owned) {
   const unusedDeclarations = owned.paths.map((p) => p.path).filter((p) => !usedDeclarations.has(p));
   return { undeclaredTouched, unusedDeclarations };
 }
+
+// src/keyed-status-delta.ts
+function sig(value) {
+  if (value === void 0) return void 0;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
+}
+function digestFields(source, ignore) {
+  const sigs = /* @__PURE__ */ new Map();
+  const values = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (ignore.has(key)) continue;
+    const s = sig(value);
+    if (s === void 0) continue;
+    sigs.set(key, s);
+    values[key] = value;
+  }
+  return { sigs, values };
+}
+function sessionSignature(session, volatile) {
+  if (volatile.size === 0) return sig(session) ?? "";
+  const stable = {};
+  for (const [key, value] of Object.entries(session)) {
+    if (!volatile.has(key)) stable[key] = value;
+  }
+  return sig(stable) ?? "";
+}
+function fieldSigsOf(digest) {
+  if (!digest.fieldSigs) {
+    const sigs = /* @__PURE__ */ new Map();
+    for (const [key, value] of Object.entries(digest.value)) {
+      const s = sig(value);
+      if (s !== void 0) sigs.set(key, s);
+    }
+    digest.fieldSigs = sigs;
+  }
+  return digest.fieldSigs;
+}
+function digestKeyedStatus(body, options = {}) {
+  const volatile = new Set(options.volatileSessionFields ?? []);
+  const top = digestFields(body, /* @__PURE__ */ new Set(["status", ...options.ignoreTopLevel ?? []]));
+  const status = digestFields(body.status, /* @__PURE__ */ new Set(["sessions", ...options.ignoreStatus ?? []]));
+  const sessions = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const session of Array.isArray(body.status?.sessions) ? body.status.sessions : []) {
+    if (!session || typeof session.id !== "string" || !session.id) continue;
+    if (sessions.has(session.id)) continue;
+    sessions.set(session.id, { value: session, sig: sessionSignature(session, volatile) });
+    order.push(session.id);
+  }
+  return { top: top.sigs, topValues: top.values, status: status.sigs, statusValues: status.values, sessions, order, volatile };
+}
+function diffFieldMaps(prev, next, nextValues) {
+  let set;
+  let unset;
+  for (const [key, s] of next) {
+    if (prev.get(key) === s) continue;
+    (set ??= {})[key] = nextValues[key];
+  }
+  for (const key of prev.keys()) {
+    if (!next.has(key)) (unset ??= []).push(key);
+  }
+  return { ...set ? { set } : {}, ...unset ? { unset } : {} };
+}
+function sameOrder(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;
+  return true;
+}
+function diffKeyedStatus(prev, next) {
+  const delta = {};
+  const top = diffFieldMaps(prev.top, next.top, next.topValues);
+  if (top.set) delta.set = top.set;
+  if (top.unset) delta.unset = top.unset;
+  const status = diffFieldMaps(prev.status, next.status, next.statusValues);
+  if (status.set) delta.statusSet = status.set;
+  if (status.unset) delta.statusUnset = status.unset;
+  for (const [id2, nextSession] of next.sessions) {
+    const prevSession = prev.sessions.get(id2);
+    if (!prevSession) {
+      ;
+      (delta.sessions ??= []).push(nextSession.value);
+      continue;
+    }
+    if (prevSession.sig === nextSession.sig) continue;
+    const prevSigs = fieldSigsOf(prevSession);
+    const nextSigs = fieldSigsOf(nextSession);
+    const change = { id: id2 };
+    let changed = false;
+    for (const [key, s] of nextSigs) {
+      if (key === "id" || prevSigs.get(key) === s) continue;
+      change[key] = nextSession.value[key];
+      changed = true;
+    }
+    const gone = [];
+    for (const key of prevSigs.keys()) {
+      if (!nextSigs.has(key)) gone.push(key);
+    }
+    if (changed) (delta.sessions ??= []).push(change);
+    if (gone.length > 0) (delta.sessionUnset ??= {})[id2] = gone;
+  }
+  for (const id2 of prev.sessions.keys()) {
+    if (!next.sessions.has(id2)) (delta.removedSessionIds ??= []).push(id2);
+  }
+  if (!sameOrder(prev.order, next.order)) delta.sessionOrder = [...next.order];
+  return Object.keys(delta).length > 0 ? delta : null;
+}
+function foldKeyedStatus(held, delta) {
+  const next = { ...held };
+  for (const key of delta.unset ?? []) delete next[key];
+  Object.assign(next, delta.set ?? {});
+  const status = { ...held.status };
+  for (const key of delta.statusUnset ?? []) delete status[key];
+  Object.assign(status, delta.statusSet ?? {});
+  const byId = /* @__PURE__ */ new Map();
+  for (const session of held.status.sessions ?? []) byId.set(session.id, session);
+  for (const id2 of delta.removedSessionIds ?? []) byId.delete(id2);
+  for (const change of delta.sessions ?? []) {
+    const base = byId.get(change.id);
+    byId.set(change.id, base ? { ...base, ...change } : { ...change });
+  }
+  for (const [id2, keys] of Object.entries(delta.sessionUnset ?? {})) {
+    const base = byId.get(id2);
+    if (!base) continue;
+    const trimmed = { ...base };
+    for (const key of keys) delete trimmed[key];
+    byId.set(id2, trimmed);
+  }
+  const order = delta.sessionOrder ?? (held.status.sessions ?? []).map((session) => session.id);
+  const sessions = [];
+  const placed = /* @__PURE__ */ new Set();
+  for (const id2 of order) {
+    const session = byId.get(id2);
+    if (!session || placed.has(id2)) continue;
+    sessions.push(session);
+    placed.add(id2);
+  }
+  for (const [id2, session] of byId) {
+    if (!placed.has(id2)) sessions.push(session);
+  }
+  status.sessions = sessions;
+  next.status = status;
+  return next;
+}
+
+// src/keyed-doc-delta.ts
+function sig2(value) {
+  if (value === void 0) return void 0;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
+}
+function isRecord3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function readPath(doc, path) {
+  const [head, tail] = splitPath(path);
+  if (!tail) return doc[head];
+  const parent = doc[head];
+  return isRecord3(parent) ? parent[tail] : void 0;
+}
+function splitPath(path) {
+  const dot = path.indexOf(".");
+  return dot < 0 ? [path, void 0] : [path.slice(0, dot), path.slice(dot + 1)];
+}
+function stripCollections(doc, spec) {
+  const out = { ...doc };
+  for (const path of Object.keys(spec.collections)) {
+    const [head, tail] = splitPath(path);
+    if (!tail) {
+      delete out[head];
+      continue;
+    }
+    const parent = out[head];
+    if (!isRecord3(parent) || !(tail in parent)) continue;
+    const copy = { ...parent };
+    delete copy[tail];
+    out[head] = copy;
+  }
+  return out;
+}
+function fieldSigsOf2(digest) {
+  if (!digest.fieldSigs) {
+    const sigs = /* @__PURE__ */ new Map();
+    for (const [key, value] of Object.entries(digest.stable)) {
+      const s = sig2(value);
+      if (s !== void 0) sigs.set(key, s);
+    }
+    digest.fieldSigs = sigs;
+  }
+  return digest.fieldSigs;
+}
+function digestKeyedDoc(doc, spec) {
+  const top = /* @__PURE__ */ new Map();
+  const topValues = {};
+  for (const [key, value] of Object.entries(stripCollections(doc, spec))) {
+    const s = sig2(value);
+    if (s === void 0) continue;
+    top.set(key, s);
+    topValues[key] = value;
+  }
+  const collections = /* @__PURE__ */ new Map();
+  for (const [path, idField] of Object.entries(spec.collections)) {
+    const list = readPath(doc, path);
+    if (!Array.isArray(list)) continue;
+    const rows = /* @__PURE__ */ new Map();
+    const order = [];
+    for (const row of list) {
+      if (!isRecord3(row)) continue;
+      const id2 = row[idField];
+      if (typeof id2 !== "string" || !id2 || rows.has(id2)) continue;
+      const stable = spec.stableRow ? spec.stableRow(path, row) : row;
+      rows.set(id2, { value: row, stable, sig: sig2(stable) ?? "" });
+      order.push(id2);
+    }
+    collections.set(path, { rows, order });
+  }
+  return { top, topValues, collections, volatile: new Set(spec.volatileTopLevel ?? []) };
+}
+function sameOrder2(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;
+  return true;
+}
+function diffCollection(prev, next, idField) {
+  if (!next) return prev ? { absent: true } : null;
+  const delta = {};
+  const prevRows = prev?.rows ?? /* @__PURE__ */ new Map();
+  const nextRows = next?.rows ?? /* @__PURE__ */ new Map();
+  for (const [id2, nextRow] of nextRows) {
+    const prevRow = prevRows.get(id2);
+    if (!prevRow) {
+      ;
+      (delta.upsert ??= []).push(nextRow.value);
+      continue;
+    }
+    if (prevRow.sig === nextRow.sig) continue;
+    const prevSigs = fieldSigsOf2(prevRow);
+    const nextSigs = fieldSigsOf2(nextRow);
+    const change = { [idField]: id2 };
+    let changed = false;
+    for (const [key, s] of nextSigs) {
+      if (key === idField || prevSigs.get(key) === s) continue;
+      change[key] = nextRow.value[key];
+      changed = true;
+    }
+    const gone = [];
+    for (const key of prevSigs.keys()) if (!nextSigs.has(key) && !(key in nextRow.value)) gone.push(key);
+    if (changed) (delta.upsert ??= []).push(change);
+    if (gone.length > 0) (delta.unsetFields ??= {})[id2] = gone;
+  }
+  for (const id2 of prevRows.keys()) {
+    if (!nextRows.has(id2)) (delta.removed ??= []).push(id2);
+  }
+  if (!sameOrder2(prev?.order ?? [], next?.order ?? [])) delta.order = [...next?.order ?? []];
+  return Object.keys(delta).length > 0 ? delta : null;
+}
+function diffKeyedDoc(prev, next, spec) {
+  const delta = {};
+  let meaningful = false;
+  let set;
+  let unset;
+  for (const [key, s] of next.top) {
+    if (prev.top.get(key) === s) continue;
+    (set ??= {})[key] = next.topValues[key];
+    if (!next.volatile.has(key)) meaningful = true;
+  }
+  for (const key of prev.top.keys()) {
+    if (next.top.has(key)) continue;
+    (unset ??= []).push(key);
+    if (!next.volatile.has(key)) meaningful = true;
+  }
+  for (const [path, idField] of Object.entries(spec.collections)) {
+    const change = diffCollection(prev.collections.get(path), next.collections.get(path), idField);
+    if (!change) continue;
+    (delta.collections ??= {})[path] = change;
+    meaningful = true;
+  }
+  if (!meaningful) return null;
+  if (set) delta.set = set;
+  if (unset) delta.unset = unset;
+  return delta;
+}
+function foldCollection(held, change, idField) {
+  const byId = /* @__PURE__ */ new Map();
+  const heldOrder = [];
+  for (const row of Array.isArray(held) ? held : []) {
+    if (!isRecord3(row) || typeof row[idField] !== "string") continue;
+    byId.set(row[idField], row);
+    heldOrder.push(row[idField]);
+  }
+  for (const id2 of change.removed ?? []) byId.delete(id2);
+  for (const row of change.upsert ?? []) {
+    const id2 = row[idField];
+    if (typeof id2 !== "string") continue;
+    const base = byId.get(id2);
+    byId.set(id2, base ? { ...base, ...row } : { ...row });
+  }
+  for (const [id2, keys] of Object.entries(change.unsetFields ?? {})) {
+    const base = byId.get(id2);
+    if (!base) continue;
+    const trimmed = { ...base };
+    for (const key of keys) delete trimmed[key];
+    byId.set(id2, trimmed);
+  }
+  const order = change.order ?? heldOrder;
+  const out = [];
+  const placed = /* @__PURE__ */ new Set();
+  for (const id2 of order) {
+    const row = byId.get(id2);
+    if (!row || placed.has(id2)) continue;
+    out.push(row);
+    placed.add(id2);
+  }
+  for (const [id2, row] of byId) if (!placed.has(id2)) out.push(row);
+  return out;
+}
+function foldKeyedDoc(held, delta, spec) {
+  const heldCollections = /* @__PURE__ */ new Map();
+  for (const path of Object.keys(spec.collections)) heldCollections.set(path, readPath(held, path));
+  const next = stripCollections(held, spec);
+  for (const key of delta.unset ?? []) delete next[key];
+  Object.assign(next, delta.set ?? {});
+  for (const [path, idField] of Object.entries(spec.collections)) {
+    const change = delta.collections?.[path];
+    const heldList = heldCollections.get(path);
+    if (change?.absent) {
+      const [head2, tail2] = splitPath(path);
+      if (!tail2) delete next[head2];
+      continue;
+    }
+    if (!change && heldList === void 0) continue;
+    const list = change ? foldCollection(heldList, change, idField) : heldList;
+    const [head, tail] = splitPath(path);
+    if (!tail) {
+      next[head] = list;
+      continue;
+    }
+    const parent = isRecord3(next[head]) ? { ...next[head] } : {};
+    parent[tail] = list;
+    next[head] = parent;
+  }
+  return next;
+}
+var MESH_STATUS_DOC_SPEC = {
+  collections: { nodes: "nodeId", "queue.tasks": "id", missions: "id" },
+  volatileTopLevel: [
+    "refreshedAt",
+    "sourceOfTruth",
+    "turnPresentationCounters",
+    "meshProtocolV2Counters",
+    "pendingRetentionCounters",
+    "meshProtocolMetrics"
+  ],
+  stableRow: (collection, row) => collection === "nodes" ? stableMeshNodeRow(row) : row
+};
+function without(value, keys) {
+  if (!isRecord3(value)) return value;
+  const out = { ...value };
+  for (const key of keys) delete out[key];
+  return out;
+}
+function stableMeshNodeRow(row) {
+  const out = { ...row };
+  delete out.lastSeenAt;
+  delete out.updatedAt;
+  delete out.last_seen_at;
+  delete out.updated_at;
+  if ("dataFreshness" in out) out.dataFreshness = without(out.dataFreshness, ["ageMs", "lastProbeAt", "staleness"]);
+  if ("connection" in out) out.connection = without(out.connection, ["lastStateChangeAt"]);
+  if ("git" in out) {
+    const git = without(out.git, ["lastCheckedAt"]);
+    if (isRecord3(git) && Array.isArray(git.submodules) && git.submodules.length === 0) delete git.submodules;
+    out.git = git;
+  }
+  if ("nodeFacts" in out) out.nodeFacts = without(out.nodeFacts, ["reportedAt"]);
+  const observation = out.gitObservation;
+  if (isRecord3(observation) && (observation.source === "self" || observation.source === "local")) {
+    out.gitObservation = without(observation, ["observedAt"]);
+  }
+  return out;
+}
 export {
   CANCEL_REASONS,
   CANONICAL_MESH_TOOL_COUNT,
@@ -3212,6 +3600,7 @@ export {
   MESH_P2P_SIGNAL_TYPES,
   MESH_RECORD_PAYLOAD_KEYS,
   MESH_SESSION_CLEANUP_MODES,
+  MESH_STATUS_DOC_SPEC,
   MESH_TASK_DIFFICULTIES,
   MESH_TASK_MODES,
   MESH_TASK_PRIORITIES,
@@ -3362,10 +3751,16 @@ export {
   deriveProviderPriorityFromSlots,
   deriveSlotsFromLegacy,
   describeModelSelection,
+  diffKeyedDoc,
+  diffKeyedStatus,
+  digestKeyedDoc,
+  digestKeyedStatus,
   effectiveModelSelectionValue,
   enumOf,
   expandDaemonIdForms,
   findOwnershipConflicts,
+  foldKeyedDoc,
+  foldKeyedStatus,
   formatQuotaAccount,
   hasGitStatusEvidence,
   hasWorkerProtocolFooter,