@cadenza.io/service 2.17.42 → 2.17.43

package/dist/browser/index.js

@@ -6346,6 +6346,40 @@ var CADENZA_DB_REQUIRED_LOCAL_SYNC_INSERT_TABLES = [
   "intent_to_task_map",
   "directional_task_graph_map"
 ];
+var AUTHORITY_QUERY_RESULT_KEYS = {
+  task: "tasks",
+  routine: "routines",
+  signal_registry: "signalRegistrys",
+  intent_registry: "intentRegistrys"
+};
+function resolveSyncQueryRows(ctx, tableName) {
+  const resultKey = AUTHORITY_QUERY_RESULT_KEYS[tableName];
+  const rows = ctx?.[resultKey];
+  return Array.isArray(rows) ? rows : [];
+}
+function resolveSyncQueryTask(isCadenzaDBReady, tableName, queryData = {}, options = {}) {
+  const localQueryTask = CadenzaService.getLocalCadenzaDBQueryTask(tableName);
+  const remoteQueryTask = isCadenzaDBReady ? CadenzaService.createCadenzaDBQueryTask(tableName, queryData, options) : void 0;
+  if (!localQueryTask && !remoteQueryTask) {
+    return void 0;
+  }
+  const targetTask = localQueryTask ?? remoteQueryTask;
+  return CadenzaService.createMetaTask(
+    `Prepare graph sync query for ${tableName}`,
+    (ctx) => ({
+      ...ctx,
+      queryData: {
+        ...ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : {},
+        ...queryData
+      }
+    }),
+    `Prepares ${tableName} graph-sync query payloads.`,
+    {
+      register: false,
+      isHidden: true
+    }
+  ).then(targetTask);
+}
 var GraphSyncController = class _GraphSyncController {
   constructor() {
     this.registeredActors = /* @__PURE__ */ new Set();
@@ -6446,6 +6480,30 @@ var GraphSyncController = class _GraphSyncController {
       },
       { concurrency: 30 }
     );
+    const authoritativeTaskQueryTask = resolveSyncQueryTask(
+      this.isCadenzaDBReady,
+      "task",
+      {},
+      { concurrency: 10 }
+    );
+    const authoritativeRoutineQueryTask = resolveSyncQueryTask(
+      this.isCadenzaDBReady,
+      "routine",
+      {},
+      { concurrency: 10 }
+    );
+    const authoritativeSignalQueryTask = resolveSyncQueryTask(
+      this.isCadenzaDBReady,
+      "signal_registry",
+      {},
+      { concurrency: 10 }
+    );
+    const authoritativeIntentQueryTask = resolveSyncQueryTask(
+      this.isCadenzaDBReady,
+      "intent_registry",
+      {},
+      { concurrency: 10 }
+    );
     this.splitRoutinesTask = CadenzaService.createMetaTask(
       "Split routines for registration",
       (ctx, emit) => {
@@ -7254,6 +7312,286 @@ var GraphSyncController = class _GraphSyncController {
         )
       )
     );
+    const reconcileTaskRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
+      "Reconcile task registration from authority",
+      (ctx, emit) => {
+        const authoritativeTasks = resolveSyncQueryRows(ctx, "task");
+        let changed = false;
+        for (const row of authoritativeTasks) {
+          const taskName = typeof row.name === "string" ? row.name : "";
+          if (!taskName) {
+            continue;
+          }
+          const task = CadenzaService.get(taskName);
+          if (!task || task.registered) {
+            continue;
+          }
+          task.registered = true;
+          changed = true;
+          emit("meta.sync_controller.task_registered", {
+            ...ctx,
+            __taskName: task.name,
+            task,
+            __authoritativeReconciliation: true
+          });
+        }
+        if (authoritativeTasks.length > 0) {
+          CadenzaService.debounce(
+            "meta.sync_controller.task_registration_settled",
+            {
+              __syncing: true,
+              __authoritativeReconciliation: true
+            },
+            300
+          );
+        }
+        return changed;
+      },
+      "Marks local tasks as registered when authority rows already exist.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const reconcileRoutineRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
+      "Reconcile routine registration from authority",
+      (ctx) => {
+        const authoritativeRoutines = resolveSyncQueryRows(ctx, "routine");
+        let changed = false;
+        for (const row of authoritativeRoutines) {
+          const routineName = typeof row.name === "string" ? row.name : "";
+          if (!routineName) {
+            continue;
+          }
+          const routine = CadenzaService.getRoutine(routineName);
+          if (!routine || routine.registered) {
+            continue;
+          }
+          routine.registered = true;
+          changed = true;
+        }
+        if (authoritativeRoutines.length > 0) {
+          CadenzaService.debounce(
+            "meta.sync_controller.routine_registration_settled",
+            {
+              __syncing: true,
+              __authoritativeReconciliation: true
+            },
+            300
+          );
+        }
+        return changed;
+      },
+      "Marks local routines as registered when authority rows already exist.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const reconcileSignalRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
+      "Reconcile signal registration from authority",
+      (ctx) => {
+        const authoritativeSignals = resolveSyncQueryRows(ctx, "signal_registry");
+        const signalObservers = CadenzaService.signalBroker.signalObservers;
+        let changed = false;
+        for (const row of authoritativeSignals) {
+          const signalName = typeof row.name === "string" ? row.name : "";
+          if (!signalName) {
+            continue;
+          }
+          const observer = signalObservers?.get(signalName);
+          if (!observer || observer.registered) {
+            continue;
+          }
+          observer.registered = true;
+          changed = true;
+        }
+        if (authoritativeSignals.length > 0) {
+          CadenzaService.debounce(
+            "meta.sync_controller.signal_registration_settled",
+            {
+              __syncing: true,
+              __authoritativeReconciliation: true
+            },
+            300
+          );
+        }
+        return changed;
+      },
+      "Marks local signals as registered when authority rows already exist.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const reconcileIntentRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
+      "Reconcile intent registration from authority",
+      (ctx) => {
+        const authoritativeIntents = resolveSyncQueryRows(ctx, "intent_registry");
+        let changed = false;
+        for (const row of authoritativeIntents) {
+          const intentName = typeof row.name === "string" ? row.name : "";
+          if (!intentName || !CadenzaService.inquiryBroker.intents.has(intentName)) {
+            continue;
+          }
+          if (this.registeredIntentDefinitions.has(intentName)) {
+            continue;
+          }
+          this.registeredIntentDefinitions.add(intentName);
+          changed = true;
+        }
+        if (authoritativeIntents.length > 0) {
+          CadenzaService.debounce(
+            "meta.sync_controller.intent_registration_settled",
+            {
+              __syncing: true,
+              __authoritativeReconciliation: true
+            },
+            300
+          );
+        }
+        return changed;
+      },
+      "Marks local intents as registered when authority rows already exist.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const authoritativeTaskReconciliationGraph = authoritativeTaskQueryTask?.then(reconcileTaskRegistrationFromAuthorityTask) ?? CadenzaService.createMetaTask(
+      "Skip authoritative task reconciliation",
+      () => false,
+      "Skips task reconciliation when no authority query task is available.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const authoritativeRoutineReconciliationGraph = authoritativeRoutineQueryTask?.then(reconcileRoutineRegistrationFromAuthorityTask) ?? CadenzaService.createMetaTask(
+      "Skip authoritative routine reconciliation",
+      () => false,
+      "Skips routine reconciliation when no authority query task is available.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const authoritativeSignalReconciliationGraph = authoritativeSignalQueryTask?.then(reconcileSignalRegistrationFromAuthorityTask) ?? CadenzaService.createMetaTask(
+      "Skip authoritative signal reconciliation",
+      () => false,
+      "Skips signal reconciliation when no authority query task is available.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const authoritativeIntentReconciliationGraph = authoritativeIntentQueryTask?.then(reconcileIntentRegistrationFromAuthorityTask) ?? CadenzaService.createMetaTask(
+      "Skip authoritative intent reconciliation",
+      () => false,
+      "Skips intent reconciliation when no authority query task is available.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const authoritativeRegistrationTriggers = [
+      "meta.service_registry.initial_sync_complete",
+      "meta.sync_requested",
+      "meta.sync_controller.synced_resource",
+      "meta.sync_controller.authority_registration_reconciliation_requested"
+    ];
+    CadenzaService.createMetaTask(
+      "Prepare authoritative task registration query",
+      (ctx) => {
+        if (!this.isCadenzaDBReady) {
+          return false;
+        }
+        const serviceName2 = resolveSyncServiceName();
+        if (!serviceName2) {
+          return false;
+        }
+        return {
+          ...ctx,
+          __syncServiceName: serviceName2,
+          queryData: {
+            filter: {
+              service_name: serviceName2
+            },
+            fields: ["name", "version", "service_name"]
+          }
+        };
+      },
+      "Builds the authority task query payload for the current service.",
+      {
+        register: false,
+        isHidden: true
+      }
+    ).doOn(...authoritativeRegistrationTriggers).then(authoritativeTaskReconciliationGraph);
+    CadenzaService.createMetaTask(
+      "Prepare authoritative routine registration query",
+      (ctx) => {
+        if (!this.isCadenzaDBReady) {
+          return false;
+        }
+        const serviceName2 = resolveSyncServiceName();
+        if (!serviceName2) {
+          return false;
+        }
+        return {
+          ...ctx,
+          __syncServiceName: serviceName2,
+          queryData: {
+            filter: {
+              service_name: serviceName2
+            },
+            fields: ["name", "version", "service_name"]
+          }
+        };
+      },
+      "Builds the authority routine query payload for the current service.",
+      {
+        register: false,
+        isHidden: true
+      }
+    ).doOn(...authoritativeRegistrationTriggers).then(authoritativeRoutineReconciliationGraph);
+    CadenzaService.createMetaTask(
+      "Prepare authoritative signal registration query",
+      (ctx) => {
+        if (!this.isCadenzaDBReady) {
+          return false;
+        }
+        return {
+          ...ctx,
+          queryData: {
+            fields: ["name"]
+          }
+        };
+      },
+      "Builds the authority signal query payload for local reconciliation.",
+      {
+        register: false,
+        isHidden: true
+      }
+    ).doOn(...authoritativeRegistrationTriggers).then(authoritativeSignalReconciliationGraph);
+    CadenzaService.createMetaTask(
+      "Prepare authoritative intent registration query",
+      (ctx) => {
+        if (!this.isCadenzaDBReady) {
+          return false;
+        }
+        return {
+          ...ctx,
+          queryData: {
+            fields: ["name"]
+          }
+        };
+      },
+      "Builds the authority intent query payload for local reconciliation.",
+      {
+        register: false,
+        isHidden: true
+      }
+    ).doOn(...authoritativeRegistrationTriggers).then(authoritativeIntentReconciliationGraph);
     CadenzaService.signalBroker.getSignalsTask.clone().doOn(
       "meta.sync_controller.sync_tick",
       "meta.service_registry.initial_sync_complete"