chainlesschain 0.162.177 → 0.162.178

package/src/lib/operation-fingerprint.js

@@ -244,10 +244,11 @@ export function resolveOperationApproval(pending, resolution, opts = {}) {
  * fs/RNG — so it is fully unit-testable and serializable alongside a session.
  */
 export class OperationApprovalRegistry {
-  constructor({ clock } = {}) {
+  constructor({ clock, store = null } = {}) {
     this._byFingerprint = new Map(); // fingerprint -> pending record
     this._activeByLogicalKey = new Map(); // logical key -> active fingerprint
     this._clock = typeof clock === "function" ? clock : null;
+    this._store = store;
   }
 
   _now() {
@@ -260,10 +261,40 @@ export class OperationApprovalRegistry {
    * can resolve.
    * @returns {{fingerprint:string, shortId:string, summary:string}}
    */
-  issue(desc = {}) {
+  issue(desc = {}, opts = {}) {
     const fingerprint = computeOperationFingerprint(desc);
     const logicalKey = operationDescriptorKey(desc);
 
+    if (this._store) {
+      const card = this._store.issueRequest({
+        requestId: opts.requestId,
+        descriptor: desc,
+        binding: opts.binding,
+        now: opts.now !== undefined ? opts.now : this._now(),
+      });
+      this._byFingerprint.set(card.fingerprint, {
+        fingerprint: card.fingerprint,
+        logicalKey,
+        requestId: card.requestId,
+        binding: opts.binding,
+        sessionId: desc.session ?? null,
+        revision: card.revision,
+        status: card.status,
+      });
+      this._activeByLogicalKey.set(logicalKey, card.fingerprint);
+      return card;
+    }
+
+    // Reissuing the exact same card must never reset a resolved record.
+    const exact = this._byFingerprint.get(fingerprint);
+    if (exact) {
+      return {
+        fingerprint,
+        shortId: shortOperationId(fingerprint),
+        summary: summarizeOperation(desc),
+      };
+    }
+
     const priorFp = this._activeByLogicalKey.get(logicalKey);
     if (priorFp && priorFp !== fingerprint) {
       const prior = this._byFingerprint.get(priorFp);
@@ -296,6 +327,37 @@ export class OperationApprovalRegistry {
    * @returns {{ok:boolean, reason:(string|null)}}
    */
   resolve(fingerprint, opts = {}) {
+    if (this._store) {
+      const cached = this._byFingerprint.get(fingerprint);
+      const requestId = opts.requestId ?? cached?.requestId;
+      if (!requestId) {
+        return { ok: false, approved: false, reason: "unknown" };
+      }
+      try {
+        const verdict = this._store.resolveRequest(requestId, {
+          fingerprint: opts.fingerprint,
+          binding: opts.binding,
+          sessionId: opts.sessionId,
+          decision: opts.decision,
+          authority: opts.authority,
+          expectedRevision: opts.expectedRevision,
+          now: opts.now !== undefined ? opts.now : this._now(),
+        });
+        if (verdict.ok && cached) {
+          cached.status = verdict.approved ? "resolved" : "rejected";
+          cached.revision = verdict.revision;
+        }
+        return verdict;
+      } catch (error) {
+        return {
+          ok: false,
+          approved: false,
+          reason: "state-unavailable",
+          errorCode: error?.code || "CC_APPROVAL_STATE_UNKNOWN",
+        };
+      }
+    }
+
     const pending = this._byFingerprint.get(fingerprint);
     if (!pending) return { ok: false, reason: "unknown" };
     const now = opts.now !== undefined ? intOrNull(opts.now) : this._now();
@@ -304,9 +366,52 @@ export class OperationApprovalRegistry {
     return verdict;
   }
 
+  /**
+   * Persist a timeout/close transition. It can only reduce authority.
+   */
+  cancel(fingerprint, opts = {}) {
+    if (this._store) {
+      const cached = this._byFingerprint.get(fingerprint);
+      const requestId = opts.requestId ?? cached?.requestId;
+      if (!requestId) {
+        return { ok: false, approved: false, reason: "unknown" };
+      }
+      try {
+        const verdict = this._store.cancelRequest(requestId, {
+          expectedRevision: opts.expectedRevision ?? cached?.revision,
+          reason: opts.reason,
+          now: opts.now !== undefined ? opts.now : this._now(),
+        });
+        if (verdict.ok && cached) {
+          cached.status =
+            verdict.reason === "expired" ? "expired" : "cancelled";
+          cached.revision = verdict.revision;
+        }
+        return verdict;
+      } catch (error) {
+        return {
+          ok: false,
+          approved: false,
+          reason: "state-unavailable",
+          errorCode: error?.code || "CC_APPROVAL_STATE_UNKNOWN",
+        };
+      }
+    }
+
+    const pending = this._byFingerprint.get(fingerprint);
+    if (!pending) return { ok: false, reason: "unknown" };
+    if (pending.resolved) return { ok: false, reason: "duplicate" };
+    pending.resolved = true;
+    return { ok: true, approved: false, reason: opts.reason || "cancelled" };
+  }
+
   /** A read-only view of a pending card (or null). */
   get(fingerprint) {
     const p = this._byFingerprint.get(fingerprint);
+    if (this._store && p?.requestId) {
+      const durable = this._store.getRequest(p.requestId);
+      return durable ? { ...durable } : null;
+    }
     return p ? { ...p } : null;
   }
 }

package/src/lib/pdh-dedicated-batch-collectors.js

@@ -0,0 +1,124 @@
+const DEDICATED_COLLECTOR_METHODS = Object.freeze({
+  "social-bilibili": "bilibiliAdbSync",
+  "social-weibo": "weiboAdbSync",
+  "social-douyin": "douyinAdbSync",
+  "social-xiaohongshu": "xhsAdbSync",
+  "social-toutiao": "toutiaoAdbSync",
+  "social-kuaishou": "kuaishouAdbSync",
+});
+
+function emptyFailureReport(report, error) {
+  return {
+    adapter: report?.adapter || "unknown",
+    status: "error",
+    rawCount: 0,
+    archivedRawCount: 0,
+    archiveFailureCount: 0,
+    entityCounts: {
+      events: 0,
+      persons: 0,
+      places: 0,
+      items: 0,
+      topics: 0,
+    },
+    invalidCount: 0,
+    kgTripleCount: 0,
+    ragDocCount: 0,
+    durationMs: 0,
+    error,
+    watermark: null,
+    watermarkDeferred: false,
+    checkpointCommitted: false,
+    pageBudget: null,
+    nextPageBudget: null,
+    scanDeferredCount: 0,
+    watermarkLookbackMs: 0,
+    collectionSinceWatermark: null,
+    attemptCount: 0,
+    retryCount: 0,
+    totalRetryDelayMs: 0,
+    retryExhausted: false,
+    retryAfterMs: null,
+    rateLimitReason: null,
+    rateLimitRemainingMinute: null,
+    rateLimitRemainingDay: null,
+    sourceRequestCount: 0,
+    sourceRequestThrottleMs: 0,
+    sourceRequestRateLimitRemainingMinute: null,
+    sourceRequestRateLimitRemainingDay: null,
+  };
+}
+
+function emit(hub, event) {
+  const listener = hub?.registry?.onSyncEvent;
+  if (typeof listener !== "function") return;
+  try {
+    listener(event);
+  } catch (_error) {
+    // Collection results must not depend on a progress listener.
+  }
+}
+
+/**
+ * Replace Registry `DEDICATED_COLLECTOR_REQUIRED` skips with host-level ADB
+ * collector results. The Registry stays host-agnostic; CLI/WS shells own the
+ * cookie extraction, signing bridges, and rooted-device collectors.
+ */
+export async function runDedicatedBatchCollectors(hub, reports) {
+  if (!Array.isArray(reports)) return reports;
+  const resolved = [...reports];
+
+  for (let index = 0; index < resolved.length; index += 1) {
+    const skipped = resolved[index];
+    if (
+      skipped?.status !== "skipped" ||
+      skipped?.skipReason !== "DEDICATED_COLLECTOR_REQUIRED"
+    ) {
+      continue;
+    }
+
+    const methodName = DEDICATED_COLLECTOR_METHODS[skipped.adapter];
+    const collect = methodName && hub?.[methodName];
+    if (typeof collect !== "function") continue;
+
+    emit(hub, {
+      kind: "sync.batch.dedicated.start",
+      adapter: skipped.adapter,
+      phase: "collecting",
+    });
+
+    let result;
+    try {
+      result = await collect.call(hub, {});
+    } catch (error) {
+      result = {
+        ok: false,
+        reason: "COLLECTOR_THREW",
+        message: error?.message || String(error),
+      };
+    }
+
+    if (result?.ok === true && result.report?.status === "ok") {
+      resolved[index] = result.report;
+    } else {
+      const reason = result?.reason || "DEDICATED_COLLECTOR_FAILED";
+      const message =
+        result?.message ||
+        result?.report?.error ||
+        "dedicated collector returned no successful SyncReport";
+      resolved[index] = emptyFailureReport(skipped, `${reason}: ${message}`);
+    }
+
+    emit(hub, {
+      kind: "sync.batch.dedicated.done",
+      adapter: skipped.adapter,
+      phase: resolved[index].status,
+      status: resolved[index].status,
+      error: resolved[index].error || null,
+    });
+  }
+
+  return resolved;
+}
+
+export { DEDICATED_COLLECTOR_METHODS };