chainlesschain 0.66.0 → 0.132.0

package/src/lib/dbevo.js

@@ -667,3 +667,341 @@ export function _resetState() {
   _suggestions.clear();
   _slowQueryThresholdMs = 100;
 }
+
+/* ═════════════════════════════════════════════════════════ *
+ *  Phase 80 V2 — Schema Baseline + Migration-Run Lifecycle
+ * ═════════════════════════════════════════════════════════ */
+
+export const SCHEMA_BASELINE_V2 = Object.freeze({
+  DRAFT: "draft",
+  VALIDATED: "validated",
+  ACTIVE: "active",
+  DEPRECATED: "deprecated",
+  RETIRED: "retired",
+});
+
+export const MIGRATION_RUN_V2 = Object.freeze({
+  QUEUED: "queued",
+  RUNNING: "running",
+  APPLIED: "applied",
+  FAILED: "failed",
+  ROLLED_BACK: "rolled_back",
+});
+
+const BASELINE_TRANSITIONS_V2 = new Map([
+  ["draft", new Set(["validated", "retired"])],
+  ["validated", new Set(["active", "retired"])],
+  ["active", new Set(["deprecated", "retired"])],
+  ["deprecated", new Set(["active", "retired"])],
+]);
+const BASELINE_TERMINALS_V2 = new Set(["retired"]);
+
+const RUN_TRANSITIONS_V2 = new Map([
+  ["queued", new Set(["running", "failed"])],
+  ["running", new Set(["applied", "failed", "rolled_back"])],
+  ["applied", new Set(["rolled_back"])],
+]);
+const RUN_TERMINALS_V2 = new Set(["failed", "rolled_back"]);
+
+export const DBEVO_DEFAULT_MAX_ACTIVE_BASELINES_PER_DB = 1;
+export const DBEVO_DEFAULT_MAX_RUNNING_MIGRATIONS_PER_DB = 1;
+export const DBEVO_DEFAULT_BASELINE_IDLE_MS = 180 * 86400000; // 180 days
+export const DBEVO_DEFAULT_MIGRATION_STUCK_MS = 30 * 60000; // 30 minutes
+
+let _maxActiveBaselinesPerDbV2 = DBEVO_DEFAULT_MAX_ACTIVE_BASELINES_PER_DB;
+let _maxRunningMigrationsPerDbV2 = DBEVO_DEFAULT_MAX_RUNNING_MIGRATIONS_PER_DB;
+let _baselineIdleMsV2 = DBEVO_DEFAULT_BASELINE_IDLE_MS;
+let _migrationStuckMsV2 = DBEVO_DEFAULT_MIGRATION_STUCK_MS;
+
+function _positiveIntV2(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 getDefaultMaxActiveBaselinesPerDbV2() {
+  return DBEVO_DEFAULT_MAX_ACTIVE_BASELINES_PER_DB;
+}
+export function getMaxActiveBaselinesPerDbV2() {
+  return _maxActiveBaselinesPerDbV2;
+}
+export function setMaxActiveBaselinesPerDbV2(n) {
+  return (_maxActiveBaselinesPerDbV2 = _positiveIntV2(
+    n,
+    "maxActiveBaselinesPerDb",
+  ));
+}
+export function getDefaultMaxRunningMigrationsPerDbV2() {
+  return DBEVO_DEFAULT_MAX_RUNNING_MIGRATIONS_PER_DB;
+}
+export function getMaxRunningMigrationsPerDbV2() {
+  return _maxRunningMigrationsPerDbV2;
+}
+export function setMaxRunningMigrationsPerDbV2(n) {
+  return (_maxRunningMigrationsPerDbV2 = _positiveIntV2(
+    n,
+    "maxRunningMigrationsPerDb",
+  ));
+}
+export function getDefaultBaselineIdleMsV2() {
+  return DBEVO_DEFAULT_BASELINE_IDLE_MS;
+}
+export function getBaselineIdleMsV2() {
+  return _baselineIdleMsV2;
+}
+export function setBaselineIdleMsV2(ms) {
+  return (_baselineIdleMsV2 = _positiveIntV2(ms, "baselineIdleMs"));
+}
+export function getDefaultMigrationStuckMsV2() {
+  return DBEVO_DEFAULT_MIGRATION_STUCK_MS;
+}
+export function getMigrationStuckMsV2() {
+  return _migrationStuckMsV2;
+}
+export function setMigrationStuckMsV2(ms) {
+  return (_migrationStuckMsV2 = _positiveIntV2(ms, "migrationStuckMs"));
+}
+
+const _baselinesV2 = new Map();
+const _runsV2 = new Map();
+
+export function registerBaselineV2(
+  _db,
+  { baselineId, databaseId, version, initialStatus, metadata } = {},
+) {
+  if (!baselineId) throw new Error("baselineId is required");
+  if (!databaseId) throw new Error("databaseId is required");
+  if (!version) throw new Error("version is required");
+  if (_baselinesV2.has(baselineId))
+    throw new Error(`Baseline ${baselineId} already exists`);
+  const status = initialStatus || SCHEMA_BASELINE_V2.DRAFT;
+  if (!Object.values(SCHEMA_BASELINE_V2).includes(status))
+    throw new Error(`Invalid initial status: ${status}`);
+  if (BASELINE_TERMINALS_V2.has(status))
+    throw new Error(`Cannot register in terminal status: ${status}`);
+  if (status === SCHEMA_BASELINE_V2.ACTIVE) {
+    if (getActiveBaselineCount(databaseId) >= _maxActiveBaselinesPerDbV2)
+      throw new Error(
+        `Database ${databaseId} reached active-baseline cap (${_maxActiveBaselinesPerDbV2})`,
+      );
+  }
+  const now = Date.now();
+  const record = {
+    baselineId,
+    databaseId,
+    version,
+    status,
+    metadata: metadata || {},
+    createdAt: now,
+    updatedAt: now,
+    lastTouchedAt: now,
+  };
+  _baselinesV2.set(baselineId, record);
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function getBaselineV2(baselineId) {
+  const r = _baselinesV2.get(baselineId);
+  return r ? { ...r, metadata: { ...r.metadata } } : null;
+}
+
+export function setBaselineStatusV2(_db, baselineId, newStatus, patch = {}) {
+  const record = _baselinesV2.get(baselineId);
+  if (!record) throw new Error(`Unknown baseline: ${baselineId}`);
+  if (!Object.values(SCHEMA_BASELINE_V2).includes(newStatus))
+    throw new Error(`Invalid status: ${newStatus}`);
+  const allowed = BASELINE_TRANSITIONS_V2.get(record.status) || new Set();
+  if (!allowed.has(newStatus))
+    throw new Error(`Invalid transition: ${record.status} -> ${newStatus}`);
+  if (newStatus === SCHEMA_BASELINE_V2.ACTIVE) {
+    if (getActiveBaselineCount(record.databaseId) >= _maxActiveBaselinesPerDbV2)
+      throw new Error(
+        `Database ${record.databaseId} reached active-baseline cap (${_maxActiveBaselinesPerDbV2})`,
+      );
+  }
+  record.status = newStatus;
+  record.updatedAt = Date.now();
+  if (patch.reason !== undefined) record.lastReason = patch.reason;
+  if (patch.metadata)
+    record.metadata = { ...record.metadata, ...patch.metadata };
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function validateBaseline(db, id, reason) {
+  return setBaselineStatusV2(db, id, SCHEMA_BASELINE_V2.VALIDATED, { reason });
+}
+export function activateBaseline(db, id, reason) {
+  return setBaselineStatusV2(db, id, SCHEMA_BASELINE_V2.ACTIVE, { reason });
+}
+export function deprecateBaseline(db, id, reason) {
+  return setBaselineStatusV2(db, id, SCHEMA_BASELINE_V2.DEPRECATED, { reason });
+}
+export function retireBaseline(db, id, reason) {
+  return setBaselineStatusV2(db, id, SCHEMA_BASELINE_V2.RETIRED, { reason });
+}
+
+export function touchBaselineActivity(baselineId) {
+  const record = _baselinesV2.get(baselineId);
+  if (!record) throw new Error(`Unknown baseline: ${baselineId}`);
+  record.lastTouchedAt = Date.now();
+  record.updatedAt = record.lastTouchedAt;
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function enqueueMigrationRunV2(
+  _db,
+  { runId, databaseId, migrationId, direction, metadata } = {},
+) {
+  if (!runId) throw new Error("runId is required");
+  if (!databaseId) throw new Error("databaseId is required");
+  if (!migrationId) throw new Error("migrationId is required");
+  if (!direction) throw new Error("direction is required");
+  if (!Object.values(MIGRATION_DIRECTION).includes(direction))
+    throw new Error(`Invalid direction: ${direction}`);
+  if (_runsV2.has(runId)) throw new Error(`Run ${runId} already exists`);
+  const now = Date.now();
+  const record = {
+    runId,
+    databaseId,
+    migrationId,
+    direction,
+    status: MIGRATION_RUN_V2.QUEUED,
+    metadata: metadata || {},
+    createdAt: now,
+    updatedAt: now,
+  };
+  _runsV2.set(runId, record);
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function getMigrationRunV2(runId) {
+  const r = _runsV2.get(runId);
+  return r ? { ...r, metadata: { ...r.metadata } } : null;
+}
+
+export function setMigrationRunStatusV2(_db, runId, newStatus, patch = {}) {
+  const record = _runsV2.get(runId);
+  if (!record) throw new Error(`Unknown run: ${runId}`);
+  if (!Object.values(MIGRATION_RUN_V2).includes(newStatus))
+    throw new Error(`Invalid status: ${newStatus}`);
+  const allowed = RUN_TRANSITIONS_V2.get(record.status) || new Set();
+  if (!allowed.has(newStatus))
+    throw new Error(`Invalid transition: ${record.status} -> ${newStatus}`);
+  if (newStatus === MIGRATION_RUN_V2.RUNNING) {
+    if (
+      getRunningMigrationCount(record.databaseId) >=
+      _maxRunningMigrationsPerDbV2
+    )
+      throw new Error(
+        `Database ${record.databaseId} reached running-migration cap (${_maxRunningMigrationsPerDbV2})`,
+      );
+    if (!record.startedAt) record.startedAt = Date.now();
+  }
+  record.status = newStatus;
+  record.updatedAt = Date.now();
+  if (patch.reason !== undefined) record.lastReason = patch.reason;
+  if (patch.metadata)
+    record.metadata = { ...record.metadata, ...patch.metadata };
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function startMigrationRun(db, id, reason) {
+  return setMigrationRunStatusV2(db, id, MIGRATION_RUN_V2.RUNNING, { reason });
+}
+export function applyMigrationRun(db, id, reason) {
+  return setMigrationRunStatusV2(db, id, MIGRATION_RUN_V2.APPLIED, { reason });
+}
+export function failMigrationRun(db, id, reason) {
+  return setMigrationRunStatusV2(db, id, MIGRATION_RUN_V2.FAILED, { reason });
+}
+export function rollbackMigrationRun(db, id, reason) {
+  return setMigrationRunStatusV2(db, id, MIGRATION_RUN_V2.ROLLED_BACK, {
+    reason,
+  });
+}
+
+export function getActiveBaselineCount(databaseId) {
+  let n = 0;
+  for (const r of _baselinesV2.values()) {
+    if (r.status !== SCHEMA_BASELINE_V2.ACTIVE) continue;
+    if (databaseId && r.databaseId !== databaseId) continue;
+    n++;
+  }
+  return n;
+}
+
+export function getRunningMigrationCount(databaseId) {
+  let n = 0;
+  for (const r of _runsV2.values()) {
+    if (r.status !== MIGRATION_RUN_V2.RUNNING) continue;
+    if (databaseId && r.databaseId !== databaseId) continue;
+    n++;
+  }
+  return n;
+}
+
+export function autoRetireIdleBaselines(_db, nowMs) {
+  const now = nowMs ?? Date.now();
+  const flipped = [];
+  for (const r of _baselinesV2.values()) {
+    if (
+      r.status === SCHEMA_BASELINE_V2.DEPRECATED ||
+      r.status === SCHEMA_BASELINE_V2.DRAFT ||
+      r.status === SCHEMA_BASELINE_V2.VALIDATED
+    ) {
+      if (now - r.lastTouchedAt > _baselineIdleMsV2) {
+        r.status = SCHEMA_BASELINE_V2.RETIRED;
+        r.updatedAt = now;
+        r.lastReason = "idle_timeout";
+        flipped.push(r.baselineId);
+      }
+    }
+  }
+  return { flipped, count: flipped.length };
+}
+
+export function autoFailStuckMigrationRuns(_db, nowMs) {
+  const now = nowMs ?? Date.now();
+  const flipped = [];
+  for (const r of _runsV2.values()) {
+    if (r.status === MIGRATION_RUN_V2.RUNNING) {
+      const anchor = r.startedAt || r.createdAt;
+      if (now - anchor > _migrationStuckMsV2) {
+        r.status = MIGRATION_RUN_V2.FAILED;
+        r.updatedAt = now;
+        r.lastReason = "migration_timeout";
+        flipped.push(r.runId);
+      }
+    }
+  }
+  return { flipped, count: flipped.length };
+}
+
+export function getDbEvoStatsV2() {
+  const baselinesByStatus = {};
+  for (const s of Object.values(SCHEMA_BASELINE_V2)) baselinesByStatus[s] = 0;
+  const runsByStatus = {};
+  for (const s of Object.values(MIGRATION_RUN_V2)) runsByStatus[s] = 0;
+  for (const r of _baselinesV2.values()) baselinesByStatus[r.status]++;
+  for (const r of _runsV2.values()) runsByStatus[r.status]++;
+  return {
+    totalBaselinesV2: _baselinesV2.size,
+    totalRunsV2: _runsV2.size,
+    maxActiveBaselinesPerDb: _maxActiveBaselinesPerDbV2,
+    maxRunningMigrationsPerDb: _maxRunningMigrationsPerDbV2,
+    baselineIdleMs: _baselineIdleMsV2,
+    migrationStuckMs: _migrationStuckMsV2,
+    baselinesByStatus,
+    runsByStatus,
+  };
+}
+
+export function _resetStateV2() {
+  _maxActiveBaselinesPerDbV2 = DBEVO_DEFAULT_MAX_ACTIVE_BASELINES_PER_DB;
+  _maxRunningMigrationsPerDbV2 = DBEVO_DEFAULT_MAX_RUNNING_MIGRATIONS_PER_DB;
+  _baselineIdleMsV2 = DBEVO_DEFAULT_BASELINE_IDLE_MS;
+  _migrationStuckMsV2 = DBEVO_DEFAULT_MIGRATION_STUCK_MS;
+  _baselinesV2.clear();
+  _runsV2.clear();
+}

package/src/lib/decentral-infra.js

@@ -443,3 +443,343 @@ export function _resetState() {
   _versions.clear();
   _routes.clear();
 }
+
+/* ═════════════════════════════════════════════════════════ *
+ *  Phase 74-75 V2 — Provider Maturity + Deal Lifecycle
+ * ═════════════════════════════════════════════════════════ */
+
+export const PROVIDER_MATURITY_V2 = Object.freeze({
+  ONBOARDING: "onboarding",
+  ACTIVE: "active",
+  DEGRADED: "degraded",
+  OFFLINE: "offline",
+  RETIRED: "retired",
+});
+
+export const DEAL_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued",
+  ACTIVE: "active",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELED: "canceled",
+});
+
+const PROVIDER_TRANSITIONS_V2 = new Map([
+  ["onboarding", new Set(["active", "retired"])],
+  ["active", new Set(["degraded", "offline", "retired"])],
+  ["degraded", new Set(["active", "offline", "retired"])],
+  ["offline", new Set(["active", "retired"])],
+]);
+const PROVIDER_TERMINALS_V2 = new Set(["retired"]);
+
+const DEAL_TRANSITIONS_V2 = new Map([
+  ["queued", new Set(["active", "canceled", "failed"])],
+  ["active", new Set(["completed", "failed", "canceled"])],
+]);
+const DEAL_TERMINALS_V2 = new Set(["completed", "failed", "canceled"]);
+
+export const DI_DEFAULT_MAX_ACTIVE_PROVIDERS_PER_OPERATOR = 20;
+export const DI_DEFAULT_MAX_ACTIVE_DEALS_PER_PROVIDER = 10;
+export const DI_DEFAULT_PROVIDER_IDLE_MS = 7 * 86400000; // 7 days
+export const DI_DEFAULT_DEAL_STUCK_MS = 24 * 3600000; // 24 hours
+
+let _maxActiveProvidersPerOperatorV2 =
+  DI_DEFAULT_MAX_ACTIVE_PROVIDERS_PER_OPERATOR;
+let _maxActiveDealsPerProviderV2 = DI_DEFAULT_MAX_ACTIVE_DEALS_PER_PROVIDER;
+let _providerIdleMsV2 = DI_DEFAULT_PROVIDER_IDLE_MS;
+let _dealStuckMsV2 = DI_DEFAULT_DEAL_STUCK_MS;
+
+function _positiveIntV2(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 getDefaultMaxActiveProvidersPerOperatorV2() {
+  return DI_DEFAULT_MAX_ACTIVE_PROVIDERS_PER_OPERATOR;
+}
+export function getMaxActiveProvidersPerOperatorV2() {
+  return _maxActiveProvidersPerOperatorV2;
+}
+export function setMaxActiveProvidersPerOperatorV2(n) {
+  return (_maxActiveProvidersPerOperatorV2 = _positiveIntV2(
+    n,
+    "maxActiveProvidersPerOperator",
+  ));
+}
+export function getDefaultMaxActiveDealsPerProviderV2() {
+  return DI_DEFAULT_MAX_ACTIVE_DEALS_PER_PROVIDER;
+}
+export function getMaxActiveDealsPerProviderV2() {
+  return _maxActiveDealsPerProviderV2;
+}
+export function setMaxActiveDealsPerProviderV2(n) {
+  return (_maxActiveDealsPerProviderV2 = _positiveIntV2(
+    n,
+    "maxActiveDealsPerProvider",
+  ));
+}
+export function getDefaultProviderIdleMsV2() {
+  return DI_DEFAULT_PROVIDER_IDLE_MS;
+}
+export function getProviderIdleMsV2() {
+  return _providerIdleMsV2;
+}
+export function setProviderIdleMsV2(ms) {
+  return (_providerIdleMsV2 = _positiveIntV2(ms, "providerIdleMs"));
+}
+export function getDefaultDealStuckMsV2() {
+  return DI_DEFAULT_DEAL_STUCK_MS;
+}
+export function getDealStuckMsV2() {
+  return _dealStuckMsV2;
+}
+export function setDealStuckMsV2(ms) {
+  return (_dealStuckMsV2 = _positiveIntV2(ms, "dealStuckMs"));
+}
+
+const _providersV2 = new Map();
+const _dealsV2 = new Map();
+
+export function registerProviderV2(
+  _db,
+  { providerId, operatorId, kind, initialStatus, metadata } = {},
+) {
+  if (!providerId) throw new Error("providerId is required");
+  if (!operatorId) throw new Error("operatorId is required");
+  if (!kind) throw new Error("kind is required");
+  if (_providersV2.has(providerId))
+    throw new Error(`Provider ${providerId} already exists`);
+  const status = initialStatus || PROVIDER_MATURITY_V2.ONBOARDING;
+  if (!Object.values(PROVIDER_MATURITY_V2).includes(status))
+    throw new Error(`Invalid initial status: ${status}`);
+  if (PROVIDER_TERMINALS_V2.has(status))
+    throw new Error(`Cannot register in terminal status: ${status}`);
+  if (status === PROVIDER_MATURITY_V2.ACTIVE) {
+    if (getActiveProviderCount(operatorId) >= _maxActiveProvidersPerOperatorV2)
+      throw new Error(
+        `Operator ${operatorId} reached active-provider cap (${_maxActiveProvidersPerOperatorV2})`,
+      );
+  }
+  const now = Date.now();
+  const record = {
+    providerId,
+    operatorId,
+    kind,
+    status,
+    metadata: metadata || {},
+    createdAt: now,
+    updatedAt: now,
+    lastHeartbeatAt: now,
+  };
+  _providersV2.set(providerId, record);
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function getProviderV2(providerId) {
+  const r = _providersV2.get(providerId);
+  return r ? { ...r, metadata: { ...r.metadata } } : null;
+}
+
+export function setProviderMaturityV2(_db, providerId, newStatus, patch = {}) {
+  const record = _providersV2.get(providerId);
+  if (!record) throw new Error(`Unknown provider: ${providerId}`);
+  if (!Object.values(PROVIDER_MATURITY_V2).includes(newStatus))
+    throw new Error(`Invalid status: ${newStatus}`);
+  const allowed = PROVIDER_TRANSITIONS_V2.get(record.status) || new Set();
+  if (!allowed.has(newStatus))
+    throw new Error(`Invalid transition: ${record.status} -> ${newStatus}`);
+  if (newStatus === PROVIDER_MATURITY_V2.ACTIVE) {
+    if (
+      getActiveProviderCount(record.operatorId) >=
+      _maxActiveProvidersPerOperatorV2
+    )
+      throw new Error(
+        `Operator ${record.operatorId} reached active-provider cap (${_maxActiveProvidersPerOperatorV2})`,
+      );
+  }
+  record.status = newStatus;
+  record.updatedAt = Date.now();
+  if (patch.reason !== undefined) record.lastReason = patch.reason;
+  if (patch.metadata)
+    record.metadata = { ...record.metadata, ...patch.metadata };
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function activateProvider(db, id, reason) {
+  return setProviderMaturityV2(db, id, PROVIDER_MATURITY_V2.ACTIVE, { reason });
+}
+export function degradeProvider(db, id, reason) {
+  return setProviderMaturityV2(db, id, PROVIDER_MATURITY_V2.DEGRADED, {
+    reason,
+  });
+}
+export function offlineProvider(db, id, reason) {
+  return setProviderMaturityV2(db, id, PROVIDER_MATURITY_V2.OFFLINE, {
+    reason,
+  });
+}
+export function retireProvider(db, id, reason) {
+  return setProviderMaturityV2(db, id, PROVIDER_MATURITY_V2.RETIRED, {
+    reason,
+  });
+}
+
+export function touchProviderHeartbeat(providerId) {
+  const record = _providersV2.get(providerId);
+  if (!record) throw new Error(`Unknown provider: ${providerId}`);
+  record.lastHeartbeatAt = Date.now();
+  record.updatedAt = record.lastHeartbeatAt;
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function enqueueDealV2(
+  _db,
+  { dealId, providerId, ownerId, metadata } = {},
+) {
+  if (!dealId) throw new Error("dealId is required");
+  if (!providerId) throw new Error("providerId is required");
+  if (!ownerId) throw new Error("ownerId is required");
+  if (!_providersV2.has(providerId))
+    throw new Error(`Unknown provider: ${providerId}`);
+  if (_dealsV2.has(dealId)) throw new Error(`Deal ${dealId} already exists`);
+  const now = Date.now();
+  const record = {
+    dealId,
+    providerId,
+    ownerId,
+    status: DEAL_LIFECYCLE_V2.QUEUED,
+    metadata: metadata || {},
+    createdAt: now,
+    updatedAt: now,
+  };
+  _dealsV2.set(dealId, record);
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function getDealV2(dealId) {
+  const r = _dealsV2.get(dealId);
+  return r ? { ...r, metadata: { ...r.metadata } } : null;
+}
+
+export function setDealStatusV2(_db, dealId, newStatus, patch = {}) {
+  const record = _dealsV2.get(dealId);
+  if (!record) throw new Error(`Unknown deal: ${dealId}`);
+  if (!Object.values(DEAL_LIFECYCLE_V2).includes(newStatus))
+    throw new Error(`Invalid status: ${newStatus}`);
+  const allowed = DEAL_TRANSITIONS_V2.get(record.status) || new Set();
+  if (!allowed.has(newStatus))
+    throw new Error(`Invalid transition: ${record.status} -> ${newStatus}`);
+  if (newStatus === DEAL_LIFECYCLE_V2.ACTIVE) {
+    if (getActiveDealCount(record.providerId) >= _maxActiveDealsPerProviderV2)
+      throw new Error(
+        `Provider ${record.providerId} reached active-deal cap (${_maxActiveDealsPerProviderV2})`,
+      );
+    if (!record.activatedAt) record.activatedAt = Date.now();
+  }
+  record.status = newStatus;
+  record.updatedAt = Date.now();
+  if (patch.reason !== undefined) record.lastReason = patch.reason;
+  if (patch.metadata)
+    record.metadata = { ...record.metadata, ...patch.metadata };
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function activateDeal(db, id, reason) {
+  return setDealStatusV2(db, id, DEAL_LIFECYCLE_V2.ACTIVE, { reason });
+}
+export function completeDeal(db, id, reason) {
+  return setDealStatusV2(db, id, DEAL_LIFECYCLE_V2.COMPLETED, { reason });
+}
+export function failDeal(db, id, reason) {
+  return setDealStatusV2(db, id, DEAL_LIFECYCLE_V2.FAILED, { reason });
+}
+export function cancelDeal(db, id, reason) {
+  return setDealStatusV2(db, id, DEAL_LIFECYCLE_V2.CANCELED, { reason });
+}
+
+export function getActiveProviderCount(operatorId) {
+  let n = 0;
+  for (const r of _providersV2.values()) {
+    if (r.status !== PROVIDER_MATURITY_V2.ACTIVE) continue;
+    if (operatorId && r.operatorId !== operatorId) continue;
+    n++;
+  }
+  return n;
+}
+
+export function getActiveDealCount(providerId) {
+  let n = 0;
+  for (const r of _dealsV2.values()) {
+    if (r.status !== DEAL_LIFECYCLE_V2.ACTIVE) continue;
+    if (providerId && r.providerId !== providerId) continue;
+    n++;
+  }
+  return n;
+}
+
+export function autoOfflineStaleProviders(_db, nowMs) {
+  const now = nowMs ?? Date.now();
+  const flipped = [];
+  for (const r of _providersV2.values()) {
+    if (
+      r.status === PROVIDER_MATURITY_V2.ACTIVE ||
+      r.status === PROVIDER_MATURITY_V2.DEGRADED
+    ) {
+      if (now - r.lastHeartbeatAt > _providerIdleMsV2) {
+        r.status = PROVIDER_MATURITY_V2.OFFLINE;
+        r.updatedAt = now;
+        r.lastReason = "heartbeat_timeout";
+        flipped.push(r.providerId);
+      }
+    }
+  }
+  return { flipped, count: flipped.length };
+}
+
+export function autoFailStuckActiveDeals(_db, nowMs) {
+  const now = nowMs ?? Date.now();
+  const flipped = [];
+  for (const r of _dealsV2.values()) {
+    if (r.status === DEAL_LIFECYCLE_V2.ACTIVE) {
+      const anchor = r.activatedAt || r.createdAt;
+      if (now - anchor > _dealStuckMsV2) {
+        r.status = DEAL_LIFECYCLE_V2.FAILED;
+        r.updatedAt = now;
+        r.lastReason = "deal_timeout";
+        flipped.push(r.dealId);
+      }
+    }
+  }
+  return { flipped, count: flipped.length };
+}
+
+export function getDecentralInfraStatsV2() {
+  const providersByStatus = {};
+  for (const s of Object.values(PROVIDER_MATURITY_V2)) providersByStatus[s] = 0;
+  const dealsByStatus = {};
+  for (const s of Object.values(DEAL_LIFECYCLE_V2)) dealsByStatus[s] = 0;
+  for (const r of _providersV2.values()) providersByStatus[r.status]++;
+  for (const r of _dealsV2.values()) dealsByStatus[r.status]++;
+  return {
+    totalProvidersV2: _providersV2.size,
+    totalDealsV2: _dealsV2.size,
+    maxActiveProvidersPerOperator: _maxActiveProvidersPerOperatorV2,
+    maxActiveDealsPerProvider: _maxActiveDealsPerProviderV2,
+    providerIdleMs: _providerIdleMsV2,
+    dealStuckMs: _dealStuckMsV2,
+    providersByStatus,
+    dealsByStatus,
+  };
+}
+
+export function _resetStateV2() {
+  _maxActiveProvidersPerOperatorV2 =
+    DI_DEFAULT_MAX_ACTIVE_PROVIDERS_PER_OPERATOR;
+  _maxActiveDealsPerProviderV2 = DI_DEFAULT_MAX_ACTIVE_DEALS_PER_PROVIDER;
+  _providerIdleMsV2 = DI_DEFAULT_PROVIDER_IDLE_MS;
+  _dealStuckMsV2 = DI_DEFAULT_DEAL_STUCK_MS;
+  _providersV2.clear();
+  _dealsV2.clear();
+}