chainlesschain 0.81.0 → 0.143.0

package/src/lib/wallet-manager.js

@@ -346,3 +346,329 @@ export function getWalletSummary(db) {
     transactionCount: txns?.c || 0,
   };
 }
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Surface — In-memory wallet-maturity + transaction-lifecycle
+ * layer. Independent of the SQLite tables; tracks wallet
+ * provisioning + tx submission/settlement with caps and auto-flip.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const WALLET_MATURITY_V2 = Object.freeze({
+  PROVISIONAL: "provisional",
+  ACTIVE: "active",
+  FROZEN: "frozen",
+  RETIRED: "retired",
+});
+
+export const TX_LIFECYCLE_V2 = Object.freeze({
+  PENDING: "pending",
+  SUBMITTED: "submitted",
+  CONFIRMED: "confirmed",
+  FAILED: "failed",
+  REJECTED: "rejected",
+});
+
+const WALLET_TRANSITIONS_V2 = new Map([
+  ["provisional", new Set(["active", "retired"])],
+  ["active", new Set(["frozen", "retired"])],
+  ["frozen", new Set(["active", "retired"])],
+  ["retired", new Set()],
+]);
+const WALLET_TERMINALS_V2 = new Set(["retired"]);
+
+const TX_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["submitted", "rejected"])],
+  ["submitted", new Set(["confirmed", "failed"])],
+  ["confirmed", new Set()],
+  ["failed", new Set()],
+  ["rejected", new Set()],
+]);
+const TX_TERMINALS_V2 = new Set(["confirmed", "failed", "rejected"]);
+
+export const WALLET_DEFAULT_MAX_ACTIVE_WALLETS_PER_OWNER = 10;
+export const WALLET_DEFAULT_MAX_PENDING_TX_PER_WALLET = 25;
+export const WALLET_DEFAULT_WALLET_IDLE_MS = 1000 * 60 * 60 * 24 * 180; // 180 days
+export const WALLET_DEFAULT_TX_STUCK_MS = 1000 * 60 * 60 * 24; // 1 day
+
+const _walletsV2 = new Map();
+const _txsV2 = new Map();
+let _maxActiveWalletsPerOwnerV2 = WALLET_DEFAULT_MAX_ACTIVE_WALLETS_PER_OWNER;
+let _maxPendingTxPerWalletV2 = WALLET_DEFAULT_MAX_PENDING_TX_PER_WALLET;
+let _walletIdleMsV2 = WALLET_DEFAULT_WALLET_IDLE_MS;
+let _txStuckMsV2 = WALLET_DEFAULT_TX_STUCK_MS;
+
+function _posIntWalletV2(n, label) {
+  const v = Math.floor(Number(n));
+  if (!Number.isFinite(v) || v <= 0)
+    throw new Error(`${label} must be a positive integer`);
+  return v;
+}
+
+export function getMaxActiveWalletsPerOwnerV2() {
+  return _maxActiveWalletsPerOwnerV2;
+}
+export function setMaxActiveWalletsPerOwnerV2(n) {
+  _maxActiveWalletsPerOwnerV2 = _posIntWalletV2(n, "maxActiveWalletsPerOwner");
+}
+export function getMaxPendingTxPerWalletV2() {
+  return _maxPendingTxPerWalletV2;
+}
+export function setMaxPendingTxPerWalletV2(n) {
+  _maxPendingTxPerWalletV2 = _posIntWalletV2(n, "maxPendingTxPerWallet");
+}
+export function getWalletIdleMsV2() {
+  return _walletIdleMsV2;
+}
+export function setWalletIdleMsV2(n) {
+  _walletIdleMsV2 = _posIntWalletV2(n, "walletIdleMs");
+}
+export function getTxStuckMsV2() {
+  return _txStuckMsV2;
+}
+export function setTxStuckMsV2(n) {
+  _txStuckMsV2 = _posIntWalletV2(n, "txStuckMs");
+}
+
+export function getActiveWalletCountV2(owner) {
+  let n = 0;
+  for (const w of _walletsV2.values()) {
+    if (w.owner === owner && w.maturity === "active") n += 1;
+  }
+  return n;
+}
+
+export function getPendingTxCountV2(walletId) {
+  let n = 0;
+  for (const t of _txsV2.values()) {
+    if (
+      t.walletId === walletId &&
+      (t.status === "pending" || t.status === "submitted")
+    )
+      n += 1;
+  }
+  return n;
+}
+
+function _copyWalletV2(w) {
+  return { ...w, metadata: { ...w.metadata } };
+}
+function _copyTxV2(t) {
+  return { ...t, metadata: { ...t.metadata } };
+}
+
+export function registerWalletV2(
+  id,
+  { owner, address, metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!owner || typeof owner !== "string")
+    throw new Error("owner must be a string");
+  if (!address || typeof address !== "string")
+    throw new Error("address must be a string");
+  if (_walletsV2.has(id)) throw new Error(`wallet ${id} already exists`);
+  const w = {
+    id,
+    owner,
+    address,
+    maturity: "provisional",
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    metadata: { ...metadata },
+  };
+  _walletsV2.set(id, w);
+  return _copyWalletV2(w);
+}
+
+export function getWalletV2(id) {
+  const w = _walletsV2.get(id);
+  return w ? _copyWalletV2(w) : null;
+}
+
+export function listWalletsV2({ owner, maturity } = {}) {
+  const out = [];
+  for (const w of _walletsV2.values()) {
+    if (owner && w.owner !== owner) continue;
+    if (maturity && w.maturity !== maturity) continue;
+    out.push(_copyWalletV2(w));
+  }
+  return out;
+}
+
+export function setWalletMaturityV2(id, next, { now = Date.now() } = {}) {
+  const w = _walletsV2.get(id);
+  if (!w) throw new Error(`wallet ${id} not found`);
+  if (!WALLET_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown wallet maturity: ${next}`);
+  if (WALLET_TERMINALS_V2.has(w.maturity))
+    throw new Error(`wallet ${id} is in terminal state ${w.maturity}`);
+  const allowed = WALLET_TRANSITIONS_V2.get(w.maturity);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition wallet from ${w.maturity} to ${next}`);
+  if (next === "active") {
+    if (w.maturity === "provisional") {
+      const count = getActiveWalletCountV2(w.owner);
+      if (count >= _maxActiveWalletsPerOwnerV2)
+        throw new Error(
+          `owner ${w.owner} already at active-wallet cap (${_maxActiveWalletsPerOwnerV2})`,
+        );
+    }
+    if (!w.activatedAt) w.activatedAt = now;
+  }
+  w.maturity = next;
+  w.lastSeenAt = now;
+  return _copyWalletV2(w);
+}
+
+export function activateWalletV2(id, opts) {
+  return setWalletMaturityV2(id, "active", opts);
+}
+export function freezeWalletV2(id, opts) {
+  return setWalletMaturityV2(id, "frozen", opts);
+}
+export function retireWalletV2(id, opts) {
+  return setWalletMaturityV2(id, "retired", opts);
+}
+
+export function touchWalletV2(id, { now = Date.now() } = {}) {
+  const w = _walletsV2.get(id);
+  if (!w) throw new Error(`wallet ${id} not found`);
+  w.lastSeenAt = now;
+  return _copyWalletV2(w);
+}
+
+export function createTxV2(
+  id,
+  { walletId, kind, amount, metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!walletId || typeof walletId !== "string")
+    throw new Error("walletId must be a string");
+  if (!kind || typeof kind !== "string")
+    throw new Error("kind must be a string");
+  if (!_walletsV2.has(walletId))
+    throw new Error(`wallet ${walletId} not found`);
+  if (_txsV2.has(id)) throw new Error(`tx ${id} already exists`);
+  const count = getPendingTxCountV2(walletId);
+  if (count >= _maxPendingTxPerWalletV2)
+    throw new Error(
+      `wallet ${walletId} already at pending-tx cap (${_maxPendingTxPerWalletV2})`,
+    );
+  const t = {
+    id,
+    walletId,
+    kind,
+    amount: amount ?? null,
+    status: "pending",
+    createdAt: now,
+    lastSeenAt: now,
+    submittedAt: null,
+    settledAt: null,
+    metadata: { ...metadata },
+  };
+  _txsV2.set(id, t);
+  return _copyTxV2(t);
+}
+
+export function getTxV2(id) {
+  const t = _txsV2.get(id);
+  return t ? _copyTxV2(t) : null;
+}
+
+export function listTxsV2({ walletId, status } = {}) {
+  const out = [];
+  for (const t of _txsV2.values()) {
+    if (walletId && t.walletId !== walletId) continue;
+    if (status && t.status !== status) continue;
+    out.push(_copyTxV2(t));
+  }
+  return out;
+}
+
+export function setTxStatusV2(id, next, { now = Date.now() } = {}) {
+  const t = _txsV2.get(id);
+  if (!t) throw new Error(`tx ${id} not found`);
+  if (!TX_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown tx status: ${next}`);
+  if (TX_TERMINALS_V2.has(t.status))
+    throw new Error(`tx ${id} is in terminal state ${t.status}`);
+  const allowed = TX_TRANSITIONS_V2.get(t.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition tx from ${t.status} to ${next}`);
+  if (next === "submitted" && !t.submittedAt) t.submittedAt = now;
+  if (TX_TERMINALS_V2.has(next) && !t.settledAt) t.settledAt = now;
+  t.status = next;
+  t.lastSeenAt = now;
+  return _copyTxV2(t);
+}
+
+export function submitTxV2(id, opts) {
+  return setTxStatusV2(id, "submitted", opts);
+}
+export function confirmTxV2(id, opts) {
+  return setTxStatusV2(id, "confirmed", opts);
+}
+export function failTxV2(id, opts) {
+  return setTxStatusV2(id, "failed", opts);
+}
+export function rejectTxV2(id, opts) {
+  return setTxStatusV2(id, "rejected", opts);
+}
+
+export function autoRetireIdleWalletsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const w of _walletsV2.values()) {
+    if (w.maturity === "retired" || w.maturity === "provisional") continue;
+    if (now - w.lastSeenAt > _walletIdleMsV2) {
+      w.maturity = "retired";
+      w.lastSeenAt = now;
+      flipped.push(_copyWalletV2(w));
+    }
+  }
+  return flipped;
+}
+
+export function autoFailStuckTxV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const t of _txsV2.values()) {
+    if (t.status !== "submitted") continue;
+    const ref = t.submittedAt ?? t.lastSeenAt;
+    if (now - ref > _txStuckMsV2) {
+      t.status = "failed";
+      t.lastSeenAt = now;
+      if (!t.settledAt) t.settledAt = now;
+      flipped.push(_copyTxV2(t));
+    }
+  }
+  return flipped;
+}
+
+export function getWalletManagerStatsV2() {
+  const walletsByMaturity = {};
+  for (const v of Object.values(WALLET_MATURITY_V2)) walletsByMaturity[v] = 0;
+  for (const w of _walletsV2.values()) walletsByMaturity[w.maturity] += 1;
+
+  const txsByStatus = {};
+  for (const v of Object.values(TX_LIFECYCLE_V2)) txsByStatus[v] = 0;
+  for (const t of _txsV2.values()) txsByStatus[t.status] += 1;
+
+  return {
+    totalWalletsV2: _walletsV2.size,
+    totalTxsV2: _txsV2.size,
+    maxActiveWalletsPerOwner: _maxActiveWalletsPerOwnerV2,
+    maxPendingTxPerWallet: _maxPendingTxPerWalletV2,
+    walletIdleMs: _walletIdleMsV2,
+    txStuckMs: _txStuckMsV2,
+    walletsByMaturity,
+    txsByStatus,
+  };
+}
+
+export function _resetStateWalletManagerV2() {
+  _walletsV2.clear();
+  _txsV2.clear();
+  _maxActiveWalletsPerOwnerV2 = WALLET_DEFAULT_MAX_ACTIVE_WALLETS_PER_OWNER;
+  _maxPendingTxPerWalletV2 = WALLET_DEFAULT_MAX_PENDING_TX_PER_WALLET;
+  _walletIdleMsV2 = WALLET_DEFAULT_WALLET_IDLE_MS;
+  _txStuckMsV2 = WALLET_DEFAULT_TX_STUCK_MS;
+}

package/src/lib/web-fetch.js

@@ -222,3 +222,84 @@ export async function webFetch(url, options = {}) {
 }
 
 export const _deps = { http, https };
+
+// ===== V2 Surface: Web Fetch governance overlay (CLI v0.142.0) =====
+export const WFET_TARGET_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", DEGRADED: "degraded", RETIRED: "retired",
+});
+export const WFET_JOB_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", FETCHING: "fetching", SUCCEEDED: "succeeded", FAILED: "failed", CANCELLED: "cancelled",
+});
+const _wfetTTrans = new Map([
+  [WFET_TARGET_MATURITY_V2.PENDING, new Set([WFET_TARGET_MATURITY_V2.ACTIVE, WFET_TARGET_MATURITY_V2.RETIRED])],
+  [WFET_TARGET_MATURITY_V2.ACTIVE, new Set([WFET_TARGET_MATURITY_V2.DEGRADED, WFET_TARGET_MATURITY_V2.RETIRED])],
+  [WFET_TARGET_MATURITY_V2.DEGRADED, new Set([WFET_TARGET_MATURITY_V2.ACTIVE, WFET_TARGET_MATURITY_V2.RETIRED])],
+  [WFET_TARGET_MATURITY_V2.RETIRED, new Set()],
+]);
+const _wfetTTerminal = new Set([WFET_TARGET_MATURITY_V2.RETIRED]);
+const _wfetJTrans = new Map([
+  [WFET_JOB_LIFECYCLE_V2.QUEUED, new Set([WFET_JOB_LIFECYCLE_V2.FETCHING, WFET_JOB_LIFECYCLE_V2.CANCELLED])],
+  [WFET_JOB_LIFECYCLE_V2.FETCHING, new Set([WFET_JOB_LIFECYCLE_V2.SUCCEEDED, WFET_JOB_LIFECYCLE_V2.FAILED, WFET_JOB_LIFECYCLE_V2.CANCELLED])],
+  [WFET_JOB_LIFECYCLE_V2.SUCCEEDED, new Set()],
+  [WFET_JOB_LIFECYCLE_V2.FAILED, new Set()],
+  [WFET_JOB_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+const _wfetTsV2 = new Map();
+const _wfetJsV2 = new Map();
+let _wfetMaxActive = 12, _wfetMaxPending = 30, _wfetIdleMs = 7 * 24 * 60 * 60 * 1000, _wfetStuckMs = 60 * 1000;
+function _wfetPos(n, label) { const v = Math.floor(Number(n)); if (!Number.isFinite(v) || v <= 0) throw new Error(`${label} must be positive integer`); return v; }
+function _wfetCheckT(from, to) { const a = _wfetTTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid wfet target transition ${from} → ${to}`); }
+function _wfetCheckJ(from, to) { const a = _wfetJTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid wfet job transition ${from} → ${to}`); }
+export function setMaxActiveWfetTargetsPerOwnerV2(n) { _wfetMaxActive = _wfetPos(n, "maxActiveWfetTargetsPerOwner"); }
+export function getMaxActiveWfetTargetsPerOwnerV2() { return _wfetMaxActive; }
+export function setMaxPendingWfetJobsPerTargetV2(n) { _wfetMaxPending = _wfetPos(n, "maxPendingWfetJobsPerTarget"); }
+export function getMaxPendingWfetJobsPerTargetV2() { return _wfetMaxPending; }
+export function setWfetTargetIdleMsV2(n) { _wfetIdleMs = _wfetPos(n, "wfetTargetIdleMs"); }
+export function getWfetTargetIdleMsV2() { return _wfetIdleMs; }
+export function setWfetJobStuckMsV2(n) { _wfetStuckMs = _wfetPos(n, "wfetJobStuckMs"); }
+export function getWfetJobStuckMsV2() { return _wfetStuckMs; }
+export function _resetStateWebFetchV2() { _wfetTsV2.clear(); _wfetJsV2.clear(); _wfetMaxActive = 12; _wfetMaxPending = 30; _wfetIdleMs = 7 * 24 * 60 * 60 * 1000; _wfetStuckMs = 60 * 1000; }
+export function registerWfetTargetV2({ id, owner, baseUrl, metadata } = {}) {
+  if (!id) throw new Error("wfet target id required"); if (!owner) throw new Error("wfet target owner required");
+  if (_wfetTsV2.has(id)) throw new Error(`wfet target ${id} already registered`);
+  const now = Date.now();
+  const t = { id, owner, baseUrl: baseUrl || "", status: WFET_TARGET_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, retiredAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _wfetTsV2.set(id, t); return { ...t, metadata: { ...t.metadata } };
+}
+function _wfetCountActive(owner) { let n = 0; for (const t of _wfetTsV2.values()) if (t.owner === owner && t.status === WFET_TARGET_MATURITY_V2.ACTIVE) n++; return n; }
+export function activateWfetTargetV2(id) {
+  const t = _wfetTsV2.get(id); if (!t) throw new Error(`wfet target ${id} not found`);
+  _wfetCheckT(t.status, WFET_TARGET_MATURITY_V2.ACTIVE);
+  const recovery = t.status === WFET_TARGET_MATURITY_V2.DEGRADED;
+  if (!recovery && _wfetCountActive(t.owner) >= _wfetMaxActive) throw new Error(`max active wfet targets for owner ${t.owner} reached`);
+  const now = Date.now(); t.status = WFET_TARGET_MATURITY_V2.ACTIVE; t.updatedAt = now; t.lastTouchedAt = now; if (!t.activatedAt) t.activatedAt = now;
+  return { ...t, metadata: { ...t.metadata } };
+}
+export function degradeWfetTargetV2(id) { const t = _wfetTsV2.get(id); if (!t) throw new Error(`wfet target ${id} not found`); _wfetCheckT(t.status, WFET_TARGET_MATURITY_V2.DEGRADED); t.status = WFET_TARGET_MATURITY_V2.DEGRADED; t.updatedAt = Date.now(); return { ...t, metadata: { ...t.metadata } }; }
+export function retireWfetTargetV2(id) { const t = _wfetTsV2.get(id); if (!t) throw new Error(`wfet target ${id} not found`); _wfetCheckT(t.status, WFET_TARGET_MATURITY_V2.RETIRED); const now = Date.now(); t.status = WFET_TARGET_MATURITY_V2.RETIRED; t.updatedAt = now; if (!t.retiredAt) t.retiredAt = now; return { ...t, metadata: { ...t.metadata } }; }
+export function touchWfetTargetV2(id) { const t = _wfetTsV2.get(id); if (!t) throw new Error(`wfet target ${id} not found`); if (_wfetTTerminal.has(t.status)) throw new Error(`cannot touch terminal wfet target ${id}`); const now = Date.now(); t.lastTouchedAt = now; t.updatedAt = now; return { ...t, metadata: { ...t.metadata } }; }
+export function getWfetTargetV2(id) { const t = _wfetTsV2.get(id); if (!t) return null; return { ...t, metadata: { ...t.metadata } }; }
+export function listWfetTargetsV2() { return [..._wfetTsV2.values()].map((t) => ({ ...t, metadata: { ...t.metadata } })); }
+function _wfetCountPending(targetId) { let n = 0; for (const j of _wfetJsV2.values()) if (j.targetId === targetId && (j.status === WFET_JOB_LIFECYCLE_V2.QUEUED || j.status === WFET_JOB_LIFECYCLE_V2.FETCHING)) n++; return n; }
+export function createWfetJobV2({ id, targetId, kind, metadata } = {}) {
+  if (!id) throw new Error("wfet job id required"); if (!targetId) throw new Error("wfet job targetId required");
+  if (_wfetJsV2.has(id)) throw new Error(`wfet job ${id} already exists`);
+  if (!_wfetTsV2.has(targetId)) throw new Error(`wfet target ${targetId} not found`);
+  if (_wfetCountPending(targetId) >= _wfetMaxPending) throw new Error(`max pending wfet jobs for target ${targetId} reached`);
+  const now = Date.now();
+  const j = { id, targetId, kind: kind || "GET", status: WFET_JOB_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _wfetJsV2.set(id, j); return { ...j, metadata: { ...j.metadata } };
+}
+export function fetchingWfetJobV2(id) { const j = _wfetJsV2.get(id); if (!j) throw new Error(`wfet job ${id} not found`); _wfetCheckJ(j.status, WFET_JOB_LIFECYCLE_V2.FETCHING); const now = Date.now(); j.status = WFET_JOB_LIFECYCLE_V2.FETCHING; j.updatedAt = now; if (!j.startedAt) j.startedAt = now; return { ...j, metadata: { ...j.metadata } }; }
+export function succeedWfetJobV2(id) { const j = _wfetJsV2.get(id); if (!j) throw new Error(`wfet job ${id} not found`); _wfetCheckJ(j.status, WFET_JOB_LIFECYCLE_V2.SUCCEEDED); const now = Date.now(); j.status = WFET_JOB_LIFECYCLE_V2.SUCCEEDED; j.updatedAt = now; if (!j.settledAt) j.settledAt = now; return { ...j, metadata: { ...j.metadata } }; }
+export function failWfetJobV2(id, reason) { const j = _wfetJsV2.get(id); if (!j) throw new Error(`wfet job ${id} not found`); _wfetCheckJ(j.status, WFET_JOB_LIFECYCLE_V2.FAILED); const now = Date.now(); j.status = WFET_JOB_LIFECYCLE_V2.FAILED; j.updatedAt = now; if (!j.settledAt) j.settledAt = now; if (reason) j.metadata.failReason = String(reason); return { ...j, metadata: { ...j.metadata } }; }
+export function cancelWfetJobV2(id, reason) { const j = _wfetJsV2.get(id); if (!j) throw new Error(`wfet job ${id} not found`); _wfetCheckJ(j.status, WFET_JOB_LIFECYCLE_V2.CANCELLED); const now = Date.now(); j.status = WFET_JOB_LIFECYCLE_V2.CANCELLED; j.updatedAt = now; if (!j.settledAt) j.settledAt = now; if (reason) j.metadata.cancelReason = String(reason); return { ...j, metadata: { ...j.metadata } }; }
+export function getWfetJobV2(id) { const j = _wfetJsV2.get(id); if (!j) return null; return { ...j, metadata: { ...j.metadata } }; }
+export function listWfetJobsV2() { return [..._wfetJsV2.values()].map((j) => ({ ...j, metadata: { ...j.metadata } })); }
+export function autoDegradeIdleWfetTargetsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const x of _wfetTsV2.values()) if (x.status === WFET_TARGET_MATURITY_V2.ACTIVE && (t - x.lastTouchedAt) >= _wfetIdleMs) { x.status = WFET_TARGET_MATURITY_V2.DEGRADED; x.updatedAt = t; flipped.push(x.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckWfetJobsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const j of _wfetJsV2.values()) if (j.status === WFET_JOB_LIFECYCLE_V2.FETCHING && j.startedAt != null && (t - j.startedAt) >= _wfetStuckMs) { j.status = WFET_JOB_LIFECYCLE_V2.FAILED; j.updatedAt = t; if (!j.settledAt) j.settledAt = t; j.metadata.failReason = "auto-fail-stuck"; flipped.push(j.id); } return { flipped, count: flipped.length }; }
+export function getWebFetchGovStatsV2() {
+  const targetsByStatus = {}; for (const v of Object.values(WFET_TARGET_MATURITY_V2)) targetsByStatus[v] = 0; for (const t of _wfetTsV2.values()) targetsByStatus[t.status]++;
+  const jobsByStatus = {}; for (const v of Object.values(WFET_JOB_LIFECYCLE_V2)) jobsByStatus[v] = 0; for (const j of _wfetJsV2.values()) jobsByStatus[j.status]++;
+  return { totalWfetTargetsV2: _wfetTsV2.size, totalWfetJobsV2: _wfetJsV2.size, maxActiveWfetTargetsPerOwner: _wfetMaxActive, maxPendingWfetJobsPerTarget: _wfetMaxPending, wfetTargetIdleMs: _wfetIdleMs, wfetJobStuckMs: _wfetStuckMs, targetsByStatus, jobsByStatus };
+}